rust-clippy: fix most warnings in `hg-core`

All of these are simple changes that for the most part are clear improvements
and the rest are at most equivalent.

The remaining warnings have to be fixed either with a bigger refactor like for
the nested "revlog" module, or in the dependency `bytes-cast`, which we own.

This will be done sometime in the future.

rust/hg-core/src/ancestors.rs

@@ -1,701 +1,702 b''
 // ancestors.rs
 //
 // Copyright 2018 Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Rust versions of generic DAG ancestors algorithms for Mercurial
 
 use super::{Graph, GraphError, Revision, NULL_REVISION};
 use crate::dagops;
 use std::cmp::max;
 use std::collections::{BinaryHeap, HashSet};
 
 /// Iterator over the ancestors of a given list of revisions
 /// This is a generic type, defined and implemented for any Graph, so that
 /// it's easy to
 ///
 /// - unit test in pure Rust
 /// - bind to main Mercurial code, potentially in several ways and have these
 ///   bindings evolve over time
 pub struct AncestorsIterator<G: Graph> {
     graph: G,
     visit: BinaryHeap<Revision>,
     seen: HashSet<Revision>,
     stoprev: Revision,
 }
 
 pub struct MissingAncestors<G: Graph> {
     graph: G,
     bases: HashSet<Revision>,
     max_base: Revision,
 }
 
 impl<G: Graph> AncestorsIterator<G> {
     /// Constructor.
     ///
     /// if `inclusive` is true, then the init revisions are emitted in
     /// particular, otherwise iteration starts from their parents.
     pub fn new(
         graph: G,
         initrevs: impl IntoIterator<Item = Revision>,
         stoprev: Revision,
         inclusive: bool,
     ) -> Result<Self, GraphError> {
         let filtered_initrevs = initrevs.into_iter().filter(|&r| r >= stoprev);
         if inclusive {
             let visit: BinaryHeap<Revision> = filtered_initrevs.collect();
             let seen = visit.iter().cloned().collect();
             return Ok(AncestorsIterator {
                 visit,
                 seen,
                 stoprev,
                 graph,
             });
         }
         let mut this = AncestorsIterator {
             visit: BinaryHeap::new(),
             seen: HashSet::new(),
             stoprev,
             graph,
         };
         this.seen.insert(NULL_REVISION);
         for rev in filtered_initrevs {
             for parent in this.graph.parents(rev)?.iter().cloned() {
                 this.conditionally_push_rev(parent);
             }
         }
         Ok(this)
     }
 
     #[inline]
     fn conditionally_push_rev(&mut self, rev: Revision) {
         if self.stoprev <= rev && self.seen.insert(rev) {
             self.visit.push(rev);
         }
     }
 
     /// Consumes partially the iterator to tell if the given target
     /// revision
     /// is in the ancestors it emits.
     /// This is meant for iterators actually dedicated to that kind of
     /// purpose
     pub fn contains(&mut self, target: Revision) -> Result<bool, GraphError> {
         if self.seen.contains(&target) && target != NULL_REVISION {
             return Ok(true);
         }
         for item in self {
             let rev = item?;
             if rev == target {
                 return Ok(true);
             }
             if rev < target {
                 return Ok(false);
             }
         }
         Ok(false)
     }
 
     pub fn peek(&self) -> Option<Revision> {
         self.visit.peek().cloned()
     }
 
     /// Tell if the iterator is about an empty set
     ///
     /// The result does not depend whether the iterator has been consumed
     /// or not.
     /// This is mostly meant for iterators backing a lazy ancestors set
     pub fn is_empty(&self) -> bool {
         if self.visit.len() > 0 {
             return false;
         }
         if self.seen.len() > 1 {
             return false;
         }
         // at this point, the seen set is at most a singleton.
         // If not `self.inclusive`, it's still possible that it has only
         // the null revision
         self.seen.is_empty() || self.seen.contains(&NULL_REVISION)
     }
 }
 
 /// Main implementation for the iterator
 ///
 /// The algorithm is the same as in `_lazyancestorsiter()` from `ancestors.py`
 /// with a few non crucial differences:
 ///
 /// - there's no filtering of invalid parent revisions. Actually, it should be
 ///   consistent and more efficient to filter them from the end caller.
 /// - we don't have the optimization for adjacent revisions (i.e., the case
 ///   where `p1 == rev - 1`), because it amounts to update the first element of
 ///   the heap without sifting, which Rust's BinaryHeap doesn't let us do.
 /// - we save a few pushes by comparing with `stoprev` before pushing
 impl<G: Graph> Iterator for AncestorsIterator<G> {
     type Item = Result<Revision, GraphError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let current = match self.visit.peek() {
             None => {
                 return None;
             }
             Some(c) => *c,
         };
         let [p1, p2] = match self.graph.parents(current) {
             Ok(ps) => ps,
             Err(e) => return Some(Err(e)),
         };
         if p1 < self.stoprev || !self.seen.insert(p1) {
             self.visit.pop();
         } else {
             *(self.visit.peek_mut().unwrap()) = p1;
         };
 
         self.conditionally_push_rev(p2);
         Some(Ok(current))
     }
 }
 
 impl<G: Graph> MissingAncestors<G> {
     pub fn new(graph: G, bases: impl IntoIterator<Item = Revision>) -> Self {
         let mut created = MissingAncestors {
             graph,
             bases: HashSet::new(),
             max_base: NULL_REVISION,
         };
         created.add_bases(bases);
         created
     }
 
     pub fn has_bases(&self) -> bool {
         !self.bases.is_empty()
     }
 
     /// Return a reference to current bases.
     ///
     /// This is useful in unit tests, but also setdiscovery.py does
     /// read the bases attribute of a ancestor.missingancestors instance.
-    pub fn get_bases<'a>(&'a self) -> &'a HashSet<Revision> {
+    pub fn get_bases(&self) -> &HashSet<Revision> {
         &self.bases
     }
 
     /// Computes the relative heads of current bases.
     ///
     /// The object is still usable after this.
     pub fn bases_heads(&self) -> Result<HashSet<Revision>, GraphError> {
         dagops::heads(&self.graph, self.bases.iter())
     }
 
     /// Consumes the object and returns the relative heads of its bases.
     pub fn into_bases_heads(
         mut self,
     ) -> Result<HashSet<Revision>, GraphError> {
         dagops::retain_heads(&self.graph, &mut self.bases)?;
         Ok(self.bases)
     }
 
     /// Add some revisions to `self.bases`
     ///
     /// Takes care of keeping `self.max_base` up to date.
     pub fn add_bases(
         &mut self,
         new_bases: impl IntoIterator<Item = Revision>,
     ) {
         let mut max_base = self.max_base;
         self.bases.extend(
             new_bases
                 .into_iter()
                 .filter(|&rev| rev != NULL_REVISION)
                 .map(|r| {
                     if r > max_base {
                         max_base = r;
                     }
                     r
                 }),
         );
         self.max_base = max_base;
     }
 
     /// Remove all ancestors of self.bases from the revs set (in place)
     pub fn remove_ancestors_from(
         &mut self,
         revs: &mut HashSet<Revision>,
     ) -> Result<(), GraphError> {
         revs.retain(|r| !self.bases.contains(r));
         // the null revision is always an ancestor. Logically speaking
         // it's debatable in case bases is empty, but the Python
         // implementation always adds NULL_REVISION to bases, making it
         // unconditionnally true.
         revs.remove(&NULL_REVISION);
         if revs.is_empty() {
             return Ok(());
         }
         // anything in revs > start is definitely not an ancestor of bases
         // revs <= start need to be investigated
         if self.max_base == NULL_REVISION {
             return Ok(());
         }
 
         // whatever happens, we'll keep at least keepcount of them
         // knowing this gives us a earlier stop condition than
         // going all the way to the root
         let keepcount = revs.iter().filter(|r| **r > self.max_base).count();
 
         let mut curr = self.max_base;
         while curr != NULL_REVISION && revs.len() > keepcount {
             if self.bases.contains(&curr) {
                 revs.remove(&curr);
                 self.add_parents(curr)?;
             }
             curr -= 1;
         }
         Ok(())
     }
 
     /// Add the parents of `rev` to `self.bases`
     ///
     /// This has no effect on `self.max_base`
     #[inline]
     fn add_parents(&mut self, rev: Revision) -> Result<(), GraphError> {
         if rev == NULL_REVISION {
             return Ok(());
         }
         for p in self.graph.parents(rev)?.iter().cloned() {
             // No need to bother the set with inserting NULL_REVISION over and
             // over
             if p != NULL_REVISION {
                 self.bases.insert(p);
             }
         }
         Ok(())
     }
 
     /// Return all the ancestors of revs that are not ancestors of self.bases
     ///
     /// This may include elements from revs.
     ///
     /// Equivalent to the revset (::revs - ::self.bases). Revs are returned in
     /// revision number order, which is a topological order.
     pub fn missing_ancestors(
         &mut self,
         revs: impl IntoIterator<Item = Revision>,
     ) -> Result<Vec<Revision>, GraphError> {
         // just for convenience and comparison with Python version
         let bases_visit = &mut self.bases;
         let mut revs: HashSet<Revision> = revs
             .into_iter()
             .filter(|r| !bases_visit.contains(r))
             .collect();
         let revs_visit = &mut revs;
         let mut both_visit: HashSet<Revision> =
-            revs_visit.intersection(&bases_visit).cloned().collect();
+            revs_visit.intersection(bases_visit).cloned().collect();
         if revs_visit.is_empty() {
             return Ok(Vec::new());
         }
         let max_revs = revs_visit.iter().cloned().max().unwrap();
         let start = max(self.max_base, max_revs);
 
         // TODO heuristics for with_capacity()?
         let mut missing: Vec<Revision> = Vec::new();
         for curr in (0..=start).rev() {
             if revs_visit.is_empty() {
                 break;
             }
             if both_visit.remove(&curr) {
                 // curr's parents might have made it into revs_visit through
                 // another path
                 for p in self.graph.parents(curr)?.iter().cloned() {
                     if p == NULL_REVISION {
                         continue;
                     }
                     revs_visit.remove(&p);
                     bases_visit.insert(p);
                     both_visit.insert(p);
                 }
             } else if revs_visit.remove(&curr) {
                 missing.push(curr);
                 for p in self.graph.parents(curr)?.iter().cloned() {
                     if p == NULL_REVISION {
                         continue;
                     }
                     if bases_visit.contains(&p) {
                         // p is already known to be an ancestor of revs_visit
                         revs_visit.remove(&p);
                         both_visit.insert(p);
                     } else if both_visit.contains(&p) {
                         // p should have been in bases_visit
                         revs_visit.remove(&p);
                         bases_visit.insert(p);
                     } else {
                         // visit later
                         revs_visit.insert(p);
                     }
                 }
             } else if bases_visit.contains(&curr) {
                 for p in self.graph.parents(curr)?.iter().cloned() {
                     if p == NULL_REVISION {
                         continue;
                     }
                     if revs_visit.remove(&p) || both_visit.contains(&p) {
                         // p is an ancestor of bases_visit, and is implicitly
                         // in revs_visit, which means p is ::revs & ::bases.
                         bases_visit.insert(p);
                         both_visit.insert(p);
                     } else {
                         bases_visit.insert(p);
                     }
                 }
             }
         }
         missing.reverse();
         Ok(missing)
     }
 }
 
 #[cfg(test)]
 mod tests {
 
     use super::*;
     use crate::testing::{SampleGraph, VecGraph};
 
     fn list_ancestors<G: Graph>(
         graph: G,
         initrevs: Vec<Revision>,
         stoprev: Revision,
         inclusive: bool,
     ) -> Vec<Revision> {
         AncestorsIterator::new(graph, initrevs, stoprev, inclusive)
             .unwrap()
             .map(|res| res.unwrap())
             .collect()
     }
 
     #[test]
     /// Same tests as test-ancestor.py, without membership
     /// (see also test-ancestor.py.out)
     fn test_list_ancestor() {
         assert_eq!(list_ancestors(SampleGraph, vec![], 0, false), vec![]);
         assert_eq!(
             list_ancestors(SampleGraph, vec![11, 13], 0, false),
             vec![8, 7, 4, 3, 2, 1, 0]
         );
         assert_eq!(
             list_ancestors(SampleGraph, vec![1, 3], 0, false),
             vec![1, 0]
         );
         assert_eq!(
             list_ancestors(SampleGraph, vec![11, 13], 0, true),
             vec![13, 11, 8, 7, 4, 3, 2, 1, 0]
         );
         assert_eq!(
             list_ancestors(SampleGraph, vec![11, 13], 6, false),
             vec![8, 7]
         );
         assert_eq!(
             list_ancestors(SampleGraph, vec![11, 13], 6, true),
             vec![13, 11, 8, 7]
         );
         assert_eq!(
             list_ancestors(SampleGraph, vec![11, 13], 11, true),
             vec![13, 11]
         );
         assert_eq!(
             list_ancestors(SampleGraph, vec![11, 13], 12, true),
             vec![13]
         );
         assert_eq!(
             list_ancestors(SampleGraph, vec![10, 1], 0, true),
             vec![10, 5, 4, 2, 1, 0]
         );
     }
 
     #[test]
     /// Corner case that's not directly in test-ancestors.py, but
     /// that happens quite often, as demonstrated by running the whole
     /// suite.
     /// For instance, run tests/test-obsolete-checkheads.t
     fn test_nullrev_input() {
         let mut iter =
             AncestorsIterator::new(SampleGraph, vec![-1], 0, false).unwrap();
         assert_eq!(iter.next(), None)
     }
 
     #[test]
     fn test_contains() {
         let mut lazy =
             AncestorsIterator::new(SampleGraph, vec![10, 1], 0, true).unwrap();
         assert!(lazy.contains(1).unwrap());
         assert!(!lazy.contains(3).unwrap());
 
         let mut lazy =
             AncestorsIterator::new(SampleGraph, vec![0], 0, false).unwrap();
         assert!(!lazy.contains(NULL_REVISION).unwrap());
     }
 
     #[test]
     fn test_peek() {
         let mut iter =
             AncestorsIterator::new(SampleGraph, vec![10], 0, true).unwrap();
         // peek() gives us the next value
         assert_eq!(iter.peek(), Some(10));
         // but it's not been consumed
         assert_eq!(iter.next(), Some(Ok(10)));
         // and iteration resumes normally
         assert_eq!(iter.next(), Some(Ok(5)));
 
         // let's drain the iterator to test peek() at the end
         while iter.next().is_some() {}
         assert_eq!(iter.peek(), None);
     }
 
     #[test]
     fn test_empty() {
         let mut iter =
             AncestorsIterator::new(SampleGraph, vec![10], 0, true).unwrap();
         assert!(!iter.is_empty());
         while iter.next().is_some() {}
         assert!(!iter.is_empty());
 
         let iter =
             AncestorsIterator::new(SampleGraph, vec![], 0, true).unwrap();
         assert!(iter.is_empty());
 
         // case where iter.seen == {NULL_REVISION}
         let iter =
             AncestorsIterator::new(SampleGraph, vec![0], 0, false).unwrap();
         assert!(iter.is_empty());
     }
 
     /// A corrupted Graph, supporting error handling tests
     #[derive(Clone, Debug)]
     struct Corrupted;
 
     impl Graph for Corrupted {
         fn parents(&self, rev: Revision) -> Result<[Revision; 2], GraphError> {
             match rev {
                 1 => Ok([0, -1]),
                 r => Err(GraphError::ParentOutOfRange(r)),
             }
         }
     }
 
     #[test]
     fn test_initrev_out_of_range() {
         // inclusive=false looks up initrev's parents right away
         match AncestorsIterator::new(SampleGraph, vec![25], 0, false) {
             Ok(_) => panic!("Should have been ParentOutOfRange"),
             Err(e) => assert_eq!(e, GraphError::ParentOutOfRange(25)),
         }
     }
 
     #[test]
     fn test_next_out_of_range() {
         // inclusive=false looks up initrev's parents right away
         let mut iter =
             AncestorsIterator::new(Corrupted, vec![1], 0, false).unwrap();
         assert_eq!(iter.next(), Some(Err(GraphError::ParentOutOfRange(0))));
     }
 
     #[test]
     /// Test constructor, add/get bases and heads
     fn test_missing_bases() -> Result<(), GraphError> {
         let mut missing_ancestors =
             MissingAncestors::new(SampleGraph, [5, 3, 1, 3].iter().cloned());
         let mut as_vec: Vec<Revision> =
             missing_ancestors.get_bases().iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         assert_eq!(as_vec, [1, 3, 5]);
         assert_eq!(missing_ancestors.max_base, 5);
 
         missing_ancestors.add_bases([3, 7, 8].iter().cloned());
         as_vec = missing_ancestors.get_bases().iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         assert_eq!(as_vec, [1, 3, 5, 7, 8]);
         assert_eq!(missing_ancestors.max_base, 8);
 
         as_vec = missing_ancestors.bases_heads()?.iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         assert_eq!(as_vec, [3, 5, 7, 8]);
         Ok(())
     }
 
     fn assert_missing_remove(
         bases: &[Revision],
         revs: &[Revision],
         expected: &[Revision],
     ) {
         let mut missing_ancestors =
             MissingAncestors::new(SampleGraph, bases.iter().cloned());
         let mut revset: HashSet<Revision> = revs.iter().cloned().collect();
         missing_ancestors
             .remove_ancestors_from(&mut revset)
             .unwrap();
         let mut as_vec: Vec<Revision> = revset.into_iter().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         assert_eq!(as_vec.as_slice(), expected);
     }
 
     #[test]
     fn test_missing_remove() {
         assert_missing_remove(
             &[1, 2, 3, 4, 7],
             Vec::from_iter(1..10).as_slice(),
             &[5, 6, 8, 9],
         );
         assert_missing_remove(&[10], &[11, 12, 13, 14], &[11, 12, 13, 14]);
         assert_missing_remove(&[7], &[1, 2, 3, 4, 5], &[3, 5]);
     }
 
     fn assert_missing_ancestors(
         bases: &[Revision],
         revs: &[Revision],
         expected: &[Revision],
     ) {
         let mut missing_ancestors =
             MissingAncestors::new(SampleGraph, bases.iter().cloned());
         let missing = missing_ancestors
             .missing_ancestors(revs.iter().cloned())
             .unwrap();
         assert_eq!(missing.as_slice(), expected);
     }
 
     #[test]
     fn test_missing_ancestors() {
         // examples taken from test-ancestors.py by having it run
         // on the same graph (both naive and fast Python algs)
         assert_missing_ancestors(&[10], &[11], &[3, 7, 11]);
         assert_missing_ancestors(&[11], &[10], &[5, 10]);
         assert_missing_ancestors(&[7], &[9, 11], &[3, 6, 9, 11]);
     }
 
     /// An interesting case found by a random generator similar to
     /// the one in test-ancestor.py. An early version of Rust MissingAncestors
     /// failed this, yet none of the integration tests of the whole suite
     /// catched it.
+    #[allow(clippy::unnecessary_cast)]
     #[test]
     fn test_remove_ancestors_from_case1() {
         let graph: VecGraph = vec![
             [NULL_REVISION, NULL_REVISION],
             [0, NULL_REVISION],
             [1, 0],
             [2, 1],
             [3, NULL_REVISION],
             [4, NULL_REVISION],
             [5, 1],
             [2, NULL_REVISION],
             [7, NULL_REVISION],
             [8, NULL_REVISION],
             [9, NULL_REVISION],
             [10, 1],
             [3, NULL_REVISION],
             [12, NULL_REVISION],
             [13, NULL_REVISION],
             [14, NULL_REVISION],
             [4, NULL_REVISION],
             [16, NULL_REVISION],
             [17, NULL_REVISION],
             [18, NULL_REVISION],
             [19, 11],
             [20, NULL_REVISION],
             [21, NULL_REVISION],
             [22, NULL_REVISION],
             [23, NULL_REVISION],
             [2, NULL_REVISION],
             [3, NULL_REVISION],
             [26, 24],
             [27, NULL_REVISION],
             [28, NULL_REVISION],
             [12, NULL_REVISION],
             [1, NULL_REVISION],
             [1, 9],
             [32, NULL_REVISION],
             [33, NULL_REVISION],
             [34, 31],
             [35, NULL_REVISION],
             [36, 26],
             [37, NULL_REVISION],
             [38, NULL_REVISION],
             [39, NULL_REVISION],
             [40, NULL_REVISION],
             [41, NULL_REVISION],
             [42, 26],
             [0, NULL_REVISION],
             [44, NULL_REVISION],
             [45, 4],
             [40, NULL_REVISION],
             [47, NULL_REVISION],
             [36, 0],
             [49, NULL_REVISION],
             [NULL_REVISION, NULL_REVISION],
             [51, NULL_REVISION],
             [52, NULL_REVISION],
             [53, NULL_REVISION],
             [14, NULL_REVISION],
             [55, NULL_REVISION],
             [15, NULL_REVISION],
             [23, NULL_REVISION],
             [58, NULL_REVISION],
             [59, NULL_REVISION],
             [2, NULL_REVISION],
             [61, 59],
             [62, NULL_REVISION],
             [63, NULL_REVISION],
             [NULL_REVISION, NULL_REVISION],
             [65, NULL_REVISION],
             [66, NULL_REVISION],
             [67, NULL_REVISION],
             [68, NULL_REVISION],
             [37, 28],
             [69, 25],
             [71, NULL_REVISION],
             [72, NULL_REVISION],
             [50, 2],
             [74, NULL_REVISION],
             [12, NULL_REVISION],
             [18, NULL_REVISION],
             [77, NULL_REVISION],
             [78, NULL_REVISION],
             [79, NULL_REVISION],
             [43, 33],
             [81, NULL_REVISION],
             [82, NULL_REVISION],
             [83, NULL_REVISION],
             [84, 45],
             [85, NULL_REVISION],
             [86, NULL_REVISION],
             [NULL_REVISION, NULL_REVISION],
             [88, NULL_REVISION],
             [NULL_REVISION, NULL_REVISION],
             [76, 83],
             [44, NULL_REVISION],
             [92, NULL_REVISION],
             [93, NULL_REVISION],
             [9, NULL_REVISION],
             [95, 67],
             [96, NULL_REVISION],
             [97, NULL_REVISION],
             [NULL_REVISION, NULL_REVISION],
         ];
         let problem_rev = 28 as Revision;
         let problem_base = 70 as Revision;
         // making the problem obvious: problem_rev is a parent of problem_base
         assert_eq!(graph.parents(problem_base).unwrap()[1], problem_rev);
 
         let mut missing_ancestors: MissingAncestors<VecGraph> =
             MissingAncestors::new(
                 graph,
                 [60, 26, 70, 3, 96, 19, 98, 49, 97, 47, 1, 6]
                     .iter()
                     .cloned(),
             );
         assert!(missing_ancestors.bases.contains(&problem_base));
 
         let mut revs: HashSet<Revision> =
             [4, 12, 41, 28, 68, 38, 1, 30, 56, 44]
                 .iter()
                 .cloned()
                 .collect();
         missing_ancestors.remove_ancestors_from(&mut revs).unwrap();
         assert!(!revs.contains(&problem_rev));
     }
 }

rust/hg-core/src/config/config.rs

@@ -1,654 +1,654 b''
 // config.rs
 //
 // Copyright 2020
 //      Valentin Gatien-Baron,
 //      Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use super::layer;
 use super::values;
 use crate::config::layer::{
     ConfigError, ConfigLayer, ConfigOrigin, ConfigValue,
 };
 use crate::config::plain_info::PlainInfo;
 use crate::utils::files::get_bytes_from_os_str;
 use format_bytes::{write_bytes, DisplayBytes};
 use std::collections::HashSet;
 use std::env;
 use std::fmt;
 use std::path::{Path, PathBuf};
 use std::str;
 
 use crate::errors::{HgResultExt, IoResultExt};
 
 /// Holds the config values for the current repository
 /// TODO update this docstring once we support more sources
 #[derive(Clone)]
 pub struct Config {
     layers: Vec<layer::ConfigLayer>,
     plain: PlainInfo,
 }
 
 impl DisplayBytes for Config {
     fn display_bytes(
         &self,
         out: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         for (index, layer) in self.layers.iter().rev().enumerate() {
             write_bytes!(
                 out,
                 b"==== Layer {} (trusted: {}) ====\n{}",
                 index,
                 if layer.trusted {
                     &b"yes"[..]
                 } else {
                     &b"no"[..]
                 },
                 layer
             )?;
         }
         Ok(())
     }
 }
 
 pub enum ConfigSource {
     /// Absolute path to a config file
     AbsPath(PathBuf),
     /// Already parsed (from the CLI, env, Python resources, etc.)
     Parsed(layer::ConfigLayer),
 }
 
 #[derive(Debug)]
 pub struct ConfigValueParseError {
     pub origin: ConfigOrigin,
     pub line: Option<usize>,
     pub section: Vec<u8>,
     pub item: Vec<u8>,
     pub value: Vec<u8>,
     pub expected_type: &'static str,
 }
 
 impl fmt::Display for ConfigValueParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // TODO: add origin and line number information, here and in
         // corresponding python code
         write!(
             f,
             "config error: {}.{} is not a {} ('{}')",
             String::from_utf8_lossy(&self.section),
             String::from_utf8_lossy(&self.item),
             self.expected_type,
             String::from_utf8_lossy(&self.value)
         )
     }
 }
 
 /// Returns true if the config item is disabled by PLAIN or PLAINEXCEPT
 fn should_ignore(plain: &PlainInfo, section: &[u8], item: &[u8]) -> bool {
     // duplication with [_applyconfig] in [ui.py],
     if !plain.is_plain() {
         return false;
     }
     if section == b"alias" {
         return plain.plainalias();
     }
     if section == b"revsetalias" {
         return plain.plainrevsetalias();
     }
     if section == b"templatealias" {
         return plain.plaintemplatealias();
     }
     if section == b"ui" {
         let to_delete: &[&[u8]] = &[
             b"debug",
             b"fallbackencoding",
             b"quiet",
             b"slash",
             b"logtemplate",
             b"message-output",
             b"statuscopies",
             b"style",
             b"traceback",
             b"verbose",
         ];
         return to_delete.contains(&item);
     }
     let sections_to_delete: &[&[u8]] =
         &[b"defaults", b"commands", b"command-templates"];
-    return sections_to_delete.contains(&section);
+    sections_to_delete.contains(&section)
 }
 
 impl Config {
     /// The configuration to use when printing configuration-loading errors
     pub fn empty() -> Self {
         Self {
             layers: Vec::new(),
             plain: PlainInfo::empty(),
         }
     }
 
     /// Load system and user configuration from various files.
     ///
     /// This is also affected by some environment variables.
     pub fn load_non_repo() -> Result<Self, ConfigError> {
         let mut config = Self::empty();
         let opt_rc_path = env::var_os("HGRCPATH");
         // HGRCPATH replaces system config
         if opt_rc_path.is_none() {
             config.add_system_config()?
         }
 
         config.add_for_environment_variable("EDITOR", b"ui", b"editor");
         config.add_for_environment_variable("VISUAL", b"ui", b"editor");
         config.add_for_environment_variable("PAGER", b"pager", b"pager");
 
         // These are set by `run-tests.py --rhg` to enable fallback for the
         // entire test suite. Alternatives would be setting configuration
         // through `$HGRCPATH` but some tests override that, or changing the
         // `hg` shell alias to include `--config` but that disrupts tests that
         // print command lines and check expected output.
         config.add_for_environment_variable(
             "RHG_ON_UNSUPPORTED",
             b"rhg",
             b"on-unsupported",
         );
         config.add_for_environment_variable(
             "RHG_FALLBACK_EXECUTABLE",
             b"rhg",
             b"fallback-executable",
         );
 
         // HGRCPATH replaces user config
         if opt_rc_path.is_none() {
             config.add_user_config()?
         }
         if let Some(rc_path) = &opt_rc_path {
             for path in env::split_paths(rc_path) {
                 if !path.as_os_str().is_empty() {
                     if path.is_dir() {
                         config.add_trusted_dir(&path)?
                     } else {
                         config.add_trusted_file(&path)?
                     }
                 }
             }
         }
         Ok(config)
     }
 
     pub fn load_cli_args(
         &mut self,
         cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>,
         color_arg: Option<Vec<u8>>,
     ) -> Result<(), ConfigError> {
         if let Some(layer) = ConfigLayer::parse_cli_args(cli_config_args)? {
             self.layers.push(layer)
         }
         if let Some(arg) = color_arg {
             let mut layer = ConfigLayer::new(ConfigOrigin::CommandLineColor);
             layer.add(b"ui"[..].into(), b"color"[..].into(), arg, None);
             self.layers.push(layer)
         }
         Ok(())
     }
 
     fn add_trusted_dir(&mut self, path: &Path) -> Result<(), ConfigError> {
         if let Some(entries) = std::fs::read_dir(path)
             .when_reading_file(path)
             .io_not_found_as_none()?
         {
             let mut file_paths = entries
                 .map(|result| {
                     result.when_reading_file(path).map(|entry| entry.path())
                 })
                 .collect::<Result<Vec<_>, _>>()?;
             file_paths.sort();
             for file_path in &file_paths {
                 if file_path.extension() == Some(std::ffi::OsStr::new("rc")) {
-                    self.add_trusted_file(&file_path)?
+                    self.add_trusted_file(file_path)?
                 }
             }
         }
         Ok(())
     }
 
     fn add_trusted_file(&mut self, path: &Path) -> Result<(), ConfigError> {
         if let Some(data) = std::fs::read(path)
             .when_reading_file(path)
             .io_not_found_as_none()?
         {
             self.layers.extend(ConfigLayer::parse(path, &data)?)
         }
         Ok(())
     }
 
     fn add_for_environment_variable(
         &mut self,
         var: &str,
         section: &[u8],
         key: &[u8],
     ) {
         if let Some(value) = env::var_os(var) {
             let origin = layer::ConfigOrigin::Environment(var.into());
             let mut layer = ConfigLayer::new(origin);
             layer.add(
                 section.to_owned(),
                 key.to_owned(),
                 get_bytes_from_os_str(value),
                 None,
             );
             self.layers.push(layer)
         }
     }
 
     #[cfg(unix)] // TODO: other platforms
     fn add_system_config(&mut self) -> Result<(), ConfigError> {
         let mut add_for_prefix = |prefix: &Path| -> Result<(), ConfigError> {
             let etc = prefix.join("etc").join("mercurial");
             self.add_trusted_file(&etc.join("hgrc"))?;
             self.add_trusted_dir(&etc.join("hgrc.d"))
         };
         let root = Path::new("/");
         // TODO: use `std::env::args_os().next().unwrap()` a.k.a. argv[0]
         // instead? TODO: can this be a relative path?
         let hg = crate::utils::current_exe()?;
         // TODO: this order (per-installation then per-system) matches
         // `systemrcpath()` in `mercurial/scmposix.py`, but
         // `mercurial/helptext/config.txt` suggests it should be reversed
         if let Some(installation_prefix) = hg.parent().and_then(Path::parent) {
             if installation_prefix != root {
-                add_for_prefix(&installation_prefix)?
+                add_for_prefix(installation_prefix)?
             }
         }
         add_for_prefix(root)?;
         Ok(())
     }
 
     #[cfg(unix)] // TODO: other plateforms
     fn add_user_config(&mut self) -> Result<(), ConfigError> {
         let opt_home = home::home_dir();
         if let Some(home) = &opt_home {
             self.add_trusted_file(&home.join(".hgrc"))?
         }
         let darwin = cfg!(any(target_os = "macos", target_os = "ios"));
         if !darwin {
             if let Some(config_home) = env::var_os("XDG_CONFIG_HOME")
                 .map(PathBuf::from)
                 .or_else(|| opt_home.map(|home| home.join(".config")))
             {
                 self.add_trusted_file(&config_home.join("hg").join("hgrc"))?
             }
         }
         Ok(())
     }
 
     /// Loads in order, which means that the precedence is the same
     /// as the order of `sources`.
     pub fn load_from_explicit_sources(
         sources: Vec<ConfigSource>,
     ) -> Result<Self, ConfigError> {
         let mut layers = vec![];
 
         for source in sources.into_iter() {
             match source {
                 ConfigSource::Parsed(c) => layers.push(c),
                 ConfigSource::AbsPath(c) => {
                     // TODO check if it should be trusted
                     // mercurial/ui.py:427
                     let data = match std::fs::read(&c) {
                         Err(_) => continue, // same as the python code
                         Ok(data) => data,
                     };
                     layers.extend(ConfigLayer::parse(&c, &data)?)
                 }
             }
         }
 
         Ok(Config {
             layers,
             plain: PlainInfo::empty(),
         })
     }
 
     /// Loads the per-repository config into a new `Config` which is combined
     /// with `self`.
     pub(crate) fn combine_with_repo(
         &self,
         repo_config_files: &[PathBuf],
     ) -> Result<Self, ConfigError> {
         let (cli_layers, other_layers) = self
             .layers
             .iter()
             .cloned()
             .partition(ConfigLayer::is_from_command_line);
 
         let mut repo_config = Self {
             layers: other_layers,
             plain: PlainInfo::empty(),
         };
         for path in repo_config_files {
             // TODO: check if this file should be trusted:
             // `mercurial/ui.py:427`
             repo_config.add_trusted_file(path)?;
         }
         repo_config.layers.extend(cli_layers);
         Ok(repo_config)
     }
 
     pub fn apply_plain(&mut self, plain: PlainInfo) {
         self.plain = plain;
     }
 
     fn get_parse<'config, T: 'config>(
         &'config self,
         section: &[u8],
         item: &[u8],
         expected_type: &'static str,
         parse: impl Fn(&'config [u8]) -> Option<T>,
     ) -> Result<Option<T>, ConfigValueParseError> {
-        match self.get_inner(&section, &item) {
+        match self.get_inner(section, item) {
             Some((layer, v)) => match parse(&v.bytes) {
                 Some(b) => Ok(Some(b)),
                 None => Err(ConfigValueParseError {
                     origin: layer.origin.to_owned(),
                     line: v.line,
                     value: v.bytes.to_owned(),
                     section: section.to_owned(),
                     item: item.to_owned(),
                     expected_type,
                 }),
             },
             None => Ok(None),
         }
     }
 
     /// Returns an `Err` if the first value found is not a valid UTF-8 string.
     /// Otherwise, returns an `Ok(value)` if found, or `None`.
     pub fn get_str(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<&str>, ConfigValueParseError> {
         self.get_parse(section, item, "ASCII or UTF-8 string", |value| {
             str::from_utf8(value).ok()
         })
     }
 
     /// Returns an `Err` if the first value found is not a valid unsigned
     /// integer. Otherwise, returns an `Ok(value)` if found, or `None`.
     pub fn get_u32(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<u32>, ConfigValueParseError> {
         self.get_parse(section, item, "valid integer", |value| {
             str::from_utf8(value).ok()?.parse().ok()
         })
     }
 
     /// Returns an `Err` if the first value found is not a valid file size
     /// value such as `30` (default unit is bytes), `7 MB`, or `42.5 kb`.
     /// Otherwise, returns an `Ok(value_in_bytes)` if found, or `None`.
     pub fn get_byte_size(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<u64>, ConfigValueParseError> {
         self.get_parse(section, item, "byte quantity", values::parse_byte_size)
     }
 
     /// Returns an `Err` if the first value found is not a valid boolean.
     /// Otherwise, returns an `Ok(option)`, where `option` is the boolean if
     /// found, or `None`.
     pub fn get_option(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<Option<bool>, ConfigValueParseError> {
         self.get_parse(section, item, "boolean", values::parse_bool)
     }
 
     /// Returns the corresponding boolean in the config. Returns `Ok(false)`
     /// if the value is not found, an `Err` if it's not a valid boolean.
     pub fn get_bool(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Result<bool, ConfigValueParseError> {
         Ok(self.get_option(section, item)?.unwrap_or(false))
     }
 
     /// Returns `true` if the extension is enabled, `false` otherwise
     pub fn is_extension_enabled(&self, extension: &[u8]) -> bool {
         let value = self.get(b"extensions", extension);
         match value {
             Some(c) => !c.starts_with(b"!"),
             None => false,
         }
     }
 
     /// If there is an `item` value in `section`, parse and return a list of
     /// byte strings.
     pub fn get_list(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<Vec<Vec<u8>>> {
         self.get(section, item).map(values::parse_list)
     }
 
     /// Returns the raw value bytes of the first one found, or `None`.
     pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&[u8]> {
         self.get_inner(section, item)
             .map(|(_, value)| value.bytes.as_ref())
     }
 
     /// Returns the raw value bytes of the first one found, or `None`.
     pub fn get_with_origin(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<(&[u8], &ConfigOrigin)> {
         self.get_inner(section, item)
             .map(|(layer, value)| (value.bytes.as_ref(), &layer.origin))
     }
 
     /// Returns the layer and the value of the first one found, or `None`.
     fn get_inner(
         &self,
         section: &[u8],
         item: &[u8],
     ) -> Option<(&ConfigLayer, &ConfigValue)> {
         // Filter out the config items that are hidden by [PLAIN].
         // This differs from python hg where we delete them from the config.
-        let should_ignore = should_ignore(&self.plain, &section, &item);
+        let should_ignore = should_ignore(&self.plain, section, item);
         for layer in self.layers.iter().rev() {
             if !layer.trusted {
                 continue;
             }
             //The [PLAIN] config should not affect the defaults.
             //
             // However, PLAIN should also affect the "tweaked" defaults (unless
             // "tweakdefault" is part of "HGPLAINEXCEPT").
             //
             // In practice the tweak-default layer is only added when it is
             // relevant, so we can safely always take it into
             // account here.
             if should_ignore && !(layer.origin == ConfigOrigin::Tweakdefaults)
             {
                 continue;
             }
-            if let Some(v) = layer.get(&section, &item) {
-                return Some((&layer, v));
+            if let Some(v) = layer.get(section, item) {
+                return Some((layer, v));
             }
         }
         None
     }
 
     /// Return all keys defined for the given section
     pub fn get_section_keys(&self, section: &[u8]) -> HashSet<&[u8]> {
         self.layers
             .iter()
             .flat_map(|layer| layer.iter_keys(section))
             .collect()
     }
 
     /// Returns whether any key is defined in the given section
     pub fn has_non_empty_section(&self, section: &[u8]) -> bool {
         self.layers
             .iter()
             .any(|layer| layer.has_non_empty_section(section))
     }
 
     /// Yields (key, value) pairs for everything in the given section
     pub fn iter_section<'a>(
         &'a self,
         section: &'a [u8],
     ) -> impl Iterator<Item = (&[u8], &[u8])> + 'a {
         // TODO: Use `Iterator`’s `.peekable()` when its `peek_mut` is
         // available:
         // https://doc.rust-lang.org/nightly/std/iter/struct.Peekable.html#method.peek_mut
         struct Peekable<I: Iterator> {
             iter: I,
             /// Remember a peeked value, even if it was None.
             peeked: Option<Option<I::Item>>,
         }
 
         impl<I: Iterator> Peekable<I> {
             fn new(iter: I) -> Self {
                 Self { iter, peeked: None }
             }
 
             fn next(&mut self) {
                 self.peeked = None
             }
 
             fn peek_mut(&mut self) -> Option<&mut I::Item> {
                 let iter = &mut self.iter;
                 self.peeked.get_or_insert_with(|| iter.next()).as_mut()
             }
         }
 
         // Deduplicate keys redefined in multiple layers
         let mut keys_already_seen = HashSet::new();
         let mut key_is_new =
             move |&(key, _value): &(&'a [u8], &'a [u8])| -> bool {
                 keys_already_seen.insert(key)
             };
         // This is similar to `flat_map` + `filter_map`, except with a single
         // closure that owns `key_is_new` (and therefore the
         // `keys_already_seen` set):
         let mut layer_iters = Peekable::new(
             self.layers
                 .iter()
                 .rev()
                 .map(move |layer| layer.iter_section(section)),
         );
         std::iter::from_fn(move || loop {
             if let Some(pair) = layer_iters.peek_mut()?.find(&mut key_is_new) {
                 return Some(pair);
             } else {
                 layer_iters.next();
             }
         })
     }
 
     /// Get raw values bytes from all layers (even untrusted ones) in order
     /// of precedence.
     #[cfg(test)]
     fn get_all(&self, section: &[u8], item: &[u8]) -> Vec<&[u8]> {
         let mut res = vec![];
         for layer in self.layers.iter().rev() {
-            if let Some(v) = layer.get(&section, &item) {
+            if let Some(v) = layer.get(section, item) {
                 res.push(v.bytes.as_ref());
             }
         }
         res
     }
 
     // a config layer that's introduced by ui.tweakdefaults
     fn tweakdefaults_layer() -> ConfigLayer {
         let mut layer = ConfigLayer::new(ConfigOrigin::Tweakdefaults);
 
         let mut add = |section: &[u8], item: &[u8], value: &[u8]| {
             layer.add(
                 section[..].into(),
                 item[..].into(),
                 value[..].into(),
                 None,
             );
         };
         // duplication of [tweakrc] from [ui.py]
         add(b"ui", b"rollback", b"False");
         add(b"ui", b"statuscopies", b"yes");
         add(b"ui", b"interface", b"curses");
         add(b"ui", b"relative-paths", b"yes");
         add(b"commands", b"grep.all-files", b"True");
         add(b"commands", b"update.check", b"noconflict");
         add(b"commands", b"status.verbose", b"True");
         add(b"commands", b"resolve.explicit-re-merge", b"True");
         add(b"git", b"git", b"1");
         add(b"git", b"showfunc", b"1");
         add(b"git", b"word-diff", b"1");
-        return layer;
+        layer
     }
 
     // introduce the tweaked defaults as implied by ui.tweakdefaults
-    pub fn tweakdefaults<'a>(&mut self) -> () {
+    pub fn tweakdefaults(&mut self) {
         self.layers.insert(0, Config::tweakdefaults_layer());
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
     use std::fs::File;
     use std::io::Write;
 
     #[test]
     fn test_include_layer_ordering() {
         let tmpdir = tempfile::tempdir().unwrap();
         let tmpdir_path = tmpdir.path();
         let mut included_file =
             File::create(&tmpdir_path.join("included.rc")).unwrap();
 
         included_file.write_all(b"[section]\nitem=value1").unwrap();
         let base_config_path = tmpdir_path.join("base.rc");
         let mut config_file = File::create(&base_config_path).unwrap();
         let data =
             b"[section]\nitem=value0\n%include included.rc\nitem=value2\n\
               [section2]\ncount = 4\nsize = 1.5 KB\nnot-count = 1.5\nnot-size = 1 ub";
         config_file.write_all(data).unwrap();
 
         let sources = vec![ConfigSource::AbsPath(base_config_path)];
         let config = Config::load_from_explicit_sources(sources)
             .expect("expected valid config");
 
         let (_, value) = config.get_inner(b"section", b"item").unwrap();
         assert_eq!(
             value,
             &ConfigValue {
                 bytes: b"value2".to_vec(),
                 line: Some(4)
             }
         );
 
         let value = config.get(b"section", b"item").unwrap();
         assert_eq!(value, b"value2",);
         assert_eq!(
             config.get_all(b"section", b"item"),
             [b"value2", b"value1", b"value0"]
         );
 
         assert_eq!(config.get_u32(b"section2", b"count").unwrap(), Some(4));
         assert_eq!(
             config.get_byte_size(b"section2", b"size").unwrap(),
             Some(1024 + 512)
         );
         assert!(config.get_u32(b"section2", b"not-count").is_err());
         assert!(config.get_byte_size(b"section2", b"not-size").is_err());
     }
 }

rust/hg-core/src/config/layer.rs

@@ -1,349 +1,345 b''
 // layer.rs
 //
 // Copyright 2020
 //      Valentin Gatien-Baron,
 //      Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::errors::HgError;
 use crate::exit_codes::CONFIG_PARSE_ERROR_ABORT;
 use crate::utils::files::{get_bytes_from_path, get_path_from_bytes};
 use format_bytes::{format_bytes, write_bytes, DisplayBytes};
 use lazy_static::lazy_static;
 use regex::bytes::Regex;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 lazy_static! {
     static ref SECTION_RE: Regex = make_regex(r"^\[([^\[]+)\]");
     static ref ITEM_RE: Regex = make_regex(r"^([^=\s][^=]*?)\s*=\s*((.*\S)?)");
     /// Continuation whitespace
     static ref CONT_RE: Regex = make_regex(r"^\s+(\S|\S.*\S)\s*$");
     static ref EMPTY_RE: Regex = make_regex(r"^(;|#|\s*$)");
     static ref COMMENT_RE: Regex = make_regex(r"^(;|#)");
     /// A directive that allows for removing previous entries
     static ref UNSET_RE: Regex = make_regex(r"^%unset\s+(\S+)");
     /// A directive that allows for including other config files
     static ref INCLUDE_RE: Regex = make_regex(r"^%include\s+(\S|\S.*\S)\s*$");
 }
 
 /// All config values separated by layers of precedence.
 /// Each config source may be split in multiple layers if `%include` directives
 /// are used.
 /// TODO detail the general precedence
 #[derive(Clone)]
 pub struct ConfigLayer {
     /// Mapping of the sections to their items
     sections: HashMap<Vec<u8>, ConfigItem>,
     /// All sections (and their items/values) in a layer share the same origin
     pub origin: ConfigOrigin,
     /// Whether this layer comes from a trusted user or group
     pub trusted: bool,
 }
 
 impl ConfigLayer {
     pub fn new(origin: ConfigOrigin) -> Self {
         ConfigLayer {
             sections: HashMap::new(),
             trusted: true, // TODO check
             origin,
         }
     }
 
     /// Parse `--config` CLI arguments and return a layer if there’s any
     pub(crate) fn parse_cli_args(
         cli_config_args: impl IntoIterator<Item = impl AsRef<[u8]>>,
     ) -> Result<Option<Self>, ConfigError> {
         fn parse_one(arg: &[u8]) -> Option<(Vec<u8>, Vec<u8>, Vec<u8>)> {
             use crate::utils::SliceExt;
 
             let (section_and_item, value) = arg.split_2(b'=')?;
             let (section, item) = section_and_item.trim().split_2(b'.')?;
             Some((
                 section.to_owned(),
                 item.to_owned(),
                 value.trim().to_owned(),
             ))
         }
 
         let mut layer = Self::new(ConfigOrigin::CommandLine);
         for arg in cli_config_args {
             let arg = arg.as_ref();
             if let Some((section, item, value)) = parse_one(arg) {
                 layer.add(section, item, value, None);
             } else {
                 Err(HgError::abort(
                     format!(
                         "abort: malformed --config option: '{}' \
                     (use --config section.name=value)",
                         String::from_utf8_lossy(arg),
                     ),
                     CONFIG_PARSE_ERROR_ABORT,
                     None,
                 ))?
             }
         }
         if layer.sections.is_empty() {
             Ok(None)
         } else {
             Ok(Some(layer))
         }
     }
 
     /// Returns whether this layer comes from `--config` CLI arguments
     pub(crate) fn is_from_command_line(&self) -> bool {
-        if let ConfigOrigin::CommandLine = self.origin {
-            true
-        } else {
-            false
-        }
+        matches!(self.origin, ConfigOrigin::CommandLine)
     }
 
     /// Add an entry to the config, overwriting the old one if already present.
     pub fn add(
         &mut self,
         section: Vec<u8>,
         item: Vec<u8>,
         value: Vec<u8>,
         line: Option<usize>,
     ) {
         self.sections
             .entry(section)
-            .or_insert_with(|| HashMap::new())
+            .or_insert_with(HashMap::new)
             .insert(item, ConfigValue { bytes: value, line });
     }
 
     /// Returns the config value in `<section>.<item>` if it exists
     pub fn get(&self, section: &[u8], item: &[u8]) -> Option<&ConfigValue> {
-        Some(self.sections.get(section)?.get(item)?)
+        self.sections.get(section)?.get(item)
     }
 
     /// Returns the keys defined in the given section
     pub fn iter_keys(&self, section: &[u8]) -> impl Iterator<Item = &[u8]> {
         self.sections
             .get(section)
             .into_iter()
             .flat_map(|section| section.keys().map(|vec| &**vec))
     }
 
     /// Returns the (key, value) pairs defined in the given section
     pub fn iter_section<'layer>(
         &'layer self,
         section: &[u8],
     ) -> impl Iterator<Item = (&'layer [u8], &'layer [u8])> {
         self.sections
             .get(section)
             .into_iter()
             .flat_map(|section| section.iter().map(|(k, v)| (&**k, &*v.bytes)))
     }
 
     /// Returns whether any key is defined in the given section
     pub fn has_non_empty_section(&self, section: &[u8]) -> bool {
         self.sections
             .get(section)
             .map_or(false, |section| !section.is_empty())
     }
 
     pub fn is_empty(&self) -> bool {
         self.sections.is_empty()
     }
 
     /// Returns a `Vec` of layers in order of precedence (so, in read order),
     /// recursively parsing the `%include` directives if any.
     pub fn parse(src: &Path, data: &[u8]) -> Result<Vec<Self>, ConfigError> {
         let mut layers = vec![];
 
         // Discard byte order mark if any
         let data = if data.starts_with(b"\xef\xbb\xbf") {
             &data[3..]
         } else {
             data
         };
 
         // TODO check if it's trusted
         let mut current_layer = Self::new(ConfigOrigin::File(src.to_owned()));
 
         let mut lines_iter =
             data.split(|b| *b == b'\n').enumerate().peekable();
         let mut section = b"".to_vec();
 
         while let Some((index, bytes)) = lines_iter.next() {
             let line = Some(index + 1);
-            if let Some(m) = INCLUDE_RE.captures(&bytes) {
+            if let Some(m) = INCLUDE_RE.captures(bytes) {
                 let filename_bytes = &m[1];
                 let filename_bytes = crate::utils::expand_vars(filename_bytes);
                 // `Path::parent` only fails for the root directory,
                 // which `src` can’t be since we’ve managed to open it as a
                 // file.
                 let dir = src
                     .parent()
                     .expect("Path::parent fail on a file we’ve read");
                 // `Path::join` with an absolute argument correctly ignores the
                 // base path
                 let filename = dir.join(&get_path_from_bytes(&filename_bytes));
                 match std::fs::read(&filename) {
                     Ok(data) => {
                         layers.push(current_layer);
                         layers.extend(Self::parse(&filename, &data)?);
                         current_layer =
                             Self::new(ConfigOrigin::File(src.to_owned()));
                     }
                     Err(error) => {
                         if error.kind() != std::io::ErrorKind::NotFound {
                             return Err(ConfigParseError {
                                 origin: ConfigOrigin::File(src.to_owned()),
                                 line,
                                 message: format_bytes!(
                                     b"cannot include {} ({})",
                                     filename_bytes,
                                     format_bytes::Utf8(error)
                                 ),
                             }
                             .into());
                         }
                     }
                 }
-            } else if let Some(_) = EMPTY_RE.captures(&bytes) {
-            } else if let Some(m) = SECTION_RE.captures(&bytes) {
+            } else if EMPTY_RE.captures(bytes).is_some() {
+            } else if let Some(m) = SECTION_RE.captures(bytes) {
                 section = m[1].to_vec();
-            } else if let Some(m) = ITEM_RE.captures(&bytes) {
+            } else if let Some(m) = ITEM_RE.captures(bytes) {
                 let item = m[1].to_vec();
                 let mut value = m[2].to_vec();
                 loop {
                     match lines_iter.peek() {
                         None => break,
                         Some((_, v)) => {
-                            if let Some(_) = COMMENT_RE.captures(&v) {
-                            } else if let Some(_) = CONT_RE.captures(&v) {
+                            if COMMENT_RE.captures(v).is_some() {
+                            } else if CONT_RE.captures(v).is_some() {
                                 value.extend(b"\n");
                                 value.extend(&m[1]);
                             } else {
                                 break;
                             }
                         }
                     };
                     lines_iter.next();
                 }
                 current_layer.add(section.clone(), item, value, line);
-            } else if let Some(m) = UNSET_RE.captures(&bytes) {
+            } else if let Some(m) = UNSET_RE.captures(bytes) {
                 if let Some(map) = current_layer.sections.get_mut(&section) {
                     map.remove(&m[1]);
                 }
             } else {
                 let message = if bytes.starts_with(b" ") {
                     format_bytes!(b"unexpected leading whitespace: {}", bytes)
                 } else {
                     bytes.to_owned()
                 };
                 return Err(ConfigParseError {
                     origin: ConfigOrigin::File(src.to_owned()),
                     line,
                     message,
                 }
                 .into());
             }
         }
         if !current_layer.is_empty() {
             layers.push(current_layer);
         }
         Ok(layers)
     }
 }
 
 impl DisplayBytes for ConfigLayer {
     fn display_bytes(
         &self,
         out: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         let mut sections: Vec<_> = self.sections.iter().collect();
         sections.sort_by(|e0, e1| e0.0.cmp(e1.0));
 
         for (section, items) in sections.into_iter() {
-            let mut items: Vec<_> = items.into_iter().collect();
+            let mut items: Vec<_> = items.iter().collect();
             items.sort_by(|e0, e1| e0.0.cmp(e1.0));
 
             for (item, config_entry) in items {
                 write_bytes!(
                     out,
                     b"{}.{}={} # {}\n",
                     section,
                     item,
                     &config_entry.bytes,
                     &self.origin,
                 )?
             }
         }
         Ok(())
     }
 }
 
 /// Mapping of section item to value.
 /// In the following:
 /// ```text
 /// [ui]
 /// paginate=no
 /// ```
 /// "paginate" is the section item and "no" the value.
 pub type ConfigItem = HashMap<Vec<u8>, ConfigValue>;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct ConfigValue {
     /// The raw bytes of the value (be it from the CLI, env or from a file)
     pub bytes: Vec<u8>,
     /// Only present if the value comes from a file, 1-indexed.
     pub line: Option<usize>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ConfigOrigin {
     /// From a configuration file
     File(PathBuf),
     /// From [ui.tweakdefaults]
     Tweakdefaults,
     /// From a `--config` CLI argument
     CommandLine,
     /// From a `--color` CLI argument
     CommandLineColor,
     /// From environment variables like `$PAGER` or `$EDITOR`
     Environment(Vec<u8>),
     /* TODO defaults (configitems.py)
      * TODO extensions
      * TODO Python resources?
      * Others? */
 }
 
 impl DisplayBytes for ConfigOrigin {
     fn display_bytes(
         &self,
         out: &mut dyn std::io::Write,
     ) -> std::io::Result<()> {
         match self {
             ConfigOrigin::File(p) => out.write_all(&get_bytes_from_path(p)),
             ConfigOrigin::CommandLine => out.write_all(b"--config"),
             ConfigOrigin::CommandLineColor => out.write_all(b"--color"),
             ConfigOrigin::Environment(e) => write_bytes!(out, b"${}", e),
             ConfigOrigin::Tweakdefaults => {
                 write_bytes!(out, b"ui.tweakdefaults")
             }
         }
     }
 }
 
 #[derive(Debug)]
 pub struct ConfigParseError {
     pub origin: ConfigOrigin,
     pub line: Option<usize>,
     pub message: Vec<u8>,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum ConfigError {
     Parse(ConfigParseError),
     Other(HgError),
 }
 
 fn make_regex(pattern: &'static str) -> Regex {
     Regex::new(pattern).expect("expected a valid regex")
 }

rust/hg-core/src/config/values.rs

@@ -1,271 +1,267 b''
 //! Parsing functions for various type of configuration values.
 //!
 //! Returning `None` indicates a syntax error. Using a `Result` would be more
 //! correct but would take more boilerplate for converting between error types,
 //! compared to using `.ok()` on inner results of various error types to
 //! convert them all to options. The `Config::get_parse` method later converts
 //! those options to results with `ConfigValueParseError`, which contains
 //! details about where the value came from (but omits details of what’s
 //! invalid inside the value).
 
 use crate::utils::SliceExt;
 
 pub(super) fn parse_bool(v: &[u8]) -> Option<bool> {
     match v.to_ascii_lowercase().as_slice() {
         b"1" | b"yes" | b"true" | b"on" | b"always" => Some(true),
         b"0" | b"no" | b"false" | b"off" | b"never" => Some(false),
         _ => None,
     }
 }
 
 pub(super) fn parse_byte_size(value: &[u8]) -> Option<u64> {
     let value = std::str::from_utf8(value).ok()?.to_ascii_lowercase();
     const UNITS: &[(&str, u64)] = &[
         ("g", 1 << 30),
         ("gb", 1 << 30),
         ("m", 1 << 20),
         ("mb", 1 << 20),
         ("k", 1 << 10),
         ("kb", 1 << 10),
         ("b", 1 << 0), // Needs to be last
     ];
     for &(unit, multiplier) in UNITS {
         if let Some(value) = value.strip_suffix(unit) {
             let float: f64 = value.trim().parse().ok()?;
             if float >= 0.0 {
                 return Some((float * multiplier as f64).round() as u64);
             } else {
                 return None;
             }
         }
     }
     value.parse().ok()
 }
 
 /// Parse a config value as a list of sub-values.
 ///
 /// Ported from `parselist` in `mercurial/utils/stringutil.py`
 
 // Note: keep behavior in sync with the Python one.
 
 // Note: this could return `Vec<Cow<[u8]>>` instead and borrow `input` when
 // possible (when there’s no backslash-escapes) but this is probably not worth
 // the complexity as config is presumably not accessed inside
 // preformance-sensitive loops.
 pub(super) fn parse_list(input: &[u8]) -> Vec<Vec<u8>> {
     // Port of Python’s `value.lstrip(b' ,\n')`
     // TODO: is this really what we want?
     let input =
         input.trim_start_matches(|b| b == b' ' || b == b',' || b == b'\n');
     parse_list_without_trim_start(input)
 }
 
 fn parse_list_without_trim_start(input: &[u8]) -> Vec<Vec<u8>> {
     // Start of port of Python’s `_configlist`
     let input = input.trim_end_matches(|b| b == b' ' || b == b',');
     if input.is_empty() {
         return Vec::new();
     }
 
     // Just to make “a string” less confusable with “a list of strings”.
     type ByteString = Vec<u8>;
 
     // These correspond to Python’s…
     let mut mode = ParserMode::Plain; // `parser`
     let mut values = Vec::new(); // `parts[:-1]`
     let mut next_value = ByteString::new(); // `parts[-1]`
     let mut offset = 0; // `offset`
 
     // Setting `parser` to `None` is instead handled by returning immediately
     enum ParserMode {
         Plain,
         Quoted,
     }
 
     loop {
         match mode {
             ParserMode::Plain => {
                 // Start of port of Python’s `_parse_plain`
                 let mut whitespace = false;
                 while let Some(&byte) = input.get(offset) {
                     if is_space(byte) || byte == b',' {
                         whitespace = true;
                         offset += 1;
                     } else {
                         break;
                     }
                 }
                 if let Some(&byte) = input.get(offset) {
                     if whitespace {
                         values.push(std::mem::take(&mut next_value))
                     }
                     if byte == b'"' && next_value.is_empty() {
                         mode = ParserMode::Quoted;
                     } else {
                         if byte == b'"' && next_value.ends_with(b"\\") {
                             next_value.pop();
                         }
                         next_value.push(byte);
                     }
                     offset += 1;
                 } else {
                     values.push(next_value);
                     return values;
                 }
             }
             ParserMode::Quoted => {
                 // Start of port of Python’s `_parse_quote`
                 if let Some(&byte) = input.get(offset) {
                     if byte == b'"' {
                         // The input contains a quoted zero-length value `""`
                         debug_assert_eq!(next_value, b"");
                         values.push(std::mem::take(&mut next_value));
                         offset += 1;
                         while let Some(&byte) = input.get(offset) {
                             if is_space(byte) || byte == b',' {
                                 offset += 1;
                             } else {
                                 break;
                             }
                         }
                         mode = ParserMode::Plain;
                         continue;
                     }
                 }
 
                 while let Some(&byte) = input.get(offset) {
                     if byte == b'"' {
                         break;
                     }
                     if byte == b'\\' && input.get(offset + 1) == Some(&b'"') {
                         next_value.push(b'"');
                         offset += 2;
                     } else {
                         next_value.push(byte);
                         offset += 1;
                     }
                 }
 
                 if offset >= input.len() {
                     // We didn’t find a closing double-quote,
                     // so treat the opening one as part of an unquoted value
                     // instead of delimiting the start of a quoted value.
 
                     // `next_value` may have had some backslash-escapes
                     // unescaped. TODO: shouldn’t we use a slice of `input`
                     // instead?
                     let mut real_values =
                         parse_list_without_trim_start(&next_value);
 
                     if let Some(first) = real_values.first_mut() {
                         first.insert(0, b'"');
                         // Drop `next_value`
                         values.extend(real_values)
                     } else {
                         next_value.push(b'"');
                         values.push(next_value);
                     }
                     return values;
                 }
 
                 // We’re not at the end of the input, which means the `while`
                 // loop above ended at at double quote. Skip
                 // over that.
                 offset += 1;
 
                 while let Some(&byte) = input.get(offset) {
                     if byte == b' ' || byte == b',' {
                         offset += 1;
                     } else {
                         break;
                     }
                 }
 
                 if offset >= input.len() {
                     values.push(next_value);
                     return values;
                 }
 
                 if offset + 1 == input.len() && input[offset] == b'"' {
                     next_value.push(b'"');
                     offset += 1;
                 } else {
                     values.push(std::mem::take(&mut next_value));
                 }
 
                 mode = ParserMode::Plain;
             }
         }
     }
 
     // https://docs.python.org/3/library/stdtypes.html?#bytes.isspace
     fn is_space(byte: u8) -> bool {
-        if let b' ' | b'\t' | b'\n' | b'\r' | b'\x0b' | b'\x0c' = byte {
-            true
-        } else {
-            false
-        }
+        matches!(byte, b' ' | b'\t' | b'\n' | b'\r' | b'\x0b' | b'\x0c')
     }
 }
 
 #[test]
 fn test_parse_list() {
     // Make `assert_eq` error messages nicer
     fn as_strings(values: &[Vec<u8>]) -> Vec<String> {
         values
             .iter()
             .map(|v| std::str::from_utf8(v.as_ref()).unwrap().to_owned())
             .collect()
     }
     macro_rules! assert_parse_list {
         ( $input: expr => [ $( $output: expr ),* ] ) => {
             assert_eq!(
                 as_strings(&parse_list($input)),
                 as_strings(&[ $( Vec::from(&$output[..]) ),* ]),
             );
         }
     }
 
     // Keep these Rust tests in sync with the Python ones in
     // `tests/test-config-parselist.py`
     assert_parse_list!(b"" => []);
     assert_parse_list!(b"," => []);
     assert_parse_list!(b"A" => [b"A"]);
     assert_parse_list!(b"B,B" => [b"B", b"B"]);
     assert_parse_list!(b", C, ,C," => [b"C", b"C"]);
     assert_parse_list!(b"\"" => [b"\""]);
     assert_parse_list!(b"\"\"" => [b"", b""]);
     assert_parse_list!(b"D,\"" => [b"D", b"\""]);
     assert_parse_list!(b"E,\"\"" => [b"E", b"", b""]);
     assert_parse_list!(b"\"F,F\"" => [b"F,F"]);
     assert_parse_list!(b"\"G,G" => [b"\"G", b"G"]);
     assert_parse_list!(b"\"H \\\",\\\"H" => [b"\"H", b",", b"H"]);
     assert_parse_list!(b"I,I\"" => [b"I", b"I\""]);
     assert_parse_list!(b"J,\"J" => [b"J", b"\"J"]);
     assert_parse_list!(b"K K" => [b"K", b"K"]);
     assert_parse_list!(b"\"K\" K" => [b"K", b"K"]);
     assert_parse_list!(b"L\tL" => [b"L", b"L"]);
     assert_parse_list!(b"\"L\"\tL" => [b"L", b"", b"L"]);
     assert_parse_list!(b"M\x0bM" => [b"M", b"M"]);
     assert_parse_list!(b"\"M\"\x0bM" => [b"M", b"", b"M"]);
     assert_parse_list!(b"\"N\"  , ,\"" => [b"N\""]);
     assert_parse_list!(b"\" ,O,  " => [b"\"", b"O"]);
 }
 
 #[test]
 fn test_parse_byte_size() {
     assert_eq!(parse_byte_size(b""), None);
     assert_eq!(parse_byte_size(b"b"), None);
 
     assert_eq!(parse_byte_size(b"12"), Some(12));
     assert_eq!(parse_byte_size(b"12b"), Some(12));
     assert_eq!(parse_byte_size(b"12 b"), Some(12));
     assert_eq!(parse_byte_size(b"12.1 b"), Some(12));
     assert_eq!(parse_byte_size(b"1.1 K"), Some(1126));
     assert_eq!(parse_byte_size(b"1.1 kB"), Some(1126));
 
     assert_eq!(parse_byte_size(b"-12 b"), None);
     assert_eq!(parse_byte_size(b"-0.1 b"), None);
     assert_eq!(parse_byte_size(b"0.1 b"), Some(0));
     assert_eq!(parse_byte_size(b"12.1 b"), Some(12));
 }

rust/hg-core/src/copy_tracing.rs

@@ -1,680 +1,677 b''
 #[cfg(test)]
 #[macro_use]
 mod tests_support;
 
 #[cfg(test)]
 mod tests;
 
 use crate::utils::hg_path::HgPath;
 use crate::utils::hg_path::HgPathBuf;
 use crate::Revision;
 use crate::NULL_REVISION;
 
 use bytes_cast::{unaligned, BytesCast};
 use im_rc::ordmap::Entry;
 use im_rc::ordmap::OrdMap;
 use im_rc::OrdSet;
 
 use std::cmp::Ordering;
 use std::collections::HashMap;
 
 pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;
 
 type PathToken = usize;
 
 #[derive(Clone, Debug)]
 struct CopySource {
     /// revision at which the copy information was added
     rev: Revision,
     /// the copy source, (Set to None in case of deletion of the associated
     /// key)
     path: Option<PathToken>,
     /// a set of previous `CopySource.rev` value directly or indirectly
     /// overwritten by this one.
     overwritten: OrdSet<Revision>,
 }
 
 impl CopySource {
     /// create a new CopySource
     ///
     /// Use this when no previous copy source existed.
     fn new(rev: Revision, path: Option<PathToken>) -> Self {
         Self {
             rev,
             path,
             overwritten: OrdSet::new(),
         }
     }
 
     /// create a new CopySource from merging two others
     ///
     /// Use this when merging two InternalPathCopies requires active merging of
     /// some entries.
     fn new_from_merge(rev: Revision, winner: &Self, loser: &Self) -> Self {
         let mut overwritten = OrdSet::new();
         overwritten.extend(winner.overwritten.iter().copied());
         overwritten.extend(loser.overwritten.iter().copied());
         overwritten.insert(winner.rev);
         overwritten.insert(loser.rev);
         Self {
             rev,
             path: winner.path,
-            overwritten: overwritten,
+            overwritten,
         }
     }
 
     /// Update the value of a pre-existing CopySource
     ///
     /// Use this when recording copy information from  parent → child edges
     fn overwrite(&mut self, rev: Revision, path: Option<PathToken>) {
         self.overwritten.insert(self.rev);
         self.rev = rev;
         self.path = path;
     }
 
     /// Mark pre-existing copy information as "dropped" by a file deletion
     ///
     /// Use this when recording copy information from  parent → child edges
     fn mark_delete(&mut self, rev: Revision) {
         self.overwritten.insert(self.rev);
         self.rev = rev;
         self.path = None;
     }
 
     /// Mark pre-existing copy information as "dropped" by a file deletion
     ///
     /// Use this when recording copy information from  parent → child edges
     fn mark_delete_with_pair(&mut self, rev: Revision, other: &Self) {
         self.overwritten.insert(self.rev);
         if other.rev != rev {
             self.overwritten.insert(other.rev);
         }
         self.overwritten.extend(other.overwritten.iter().copied());
         self.rev = rev;
         self.path = None;
     }
 
     fn is_overwritten_by(&self, other: &Self) -> bool {
         other.overwritten.contains(&self.rev)
     }
 }
 
 // For the same "dest", content generated for a given revision will always be
 // the same.
 impl PartialEq for CopySource {
     fn eq(&self, other: &Self) -> bool {
         #[cfg(debug_assertions)]
         {
             if self.rev == other.rev {
                 debug_assert!(self.path == other.path);
                 debug_assert!(self.overwritten == other.overwritten);
             }
         }
         self.rev == other.rev
     }
 }
 
 /// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)
 type InternalPathCopies = OrdMap<PathToken, CopySource>;
 
 /// Represent active changes that affect the copy tracing.
 enum Action<'a> {
     /// The parent ? children edge is removing a file
     ///
     /// (actually, this could be the edge from the other parent, but it does
     /// not matters)
     Removed(&'a HgPath),
     /// The parent ? children edge introduce copy information between (dest,
     /// source)
     CopiedFromP1(&'a HgPath, &'a HgPath),
     CopiedFromP2(&'a HgPath, &'a HgPath),
 }
 
 /// This express the possible "special" case we can get in a merge
 ///
 /// See mercurial/metadata.py for details on these values.
 #[derive(PartialEq)]
 enum MergeCase {
     /// Merged: file had history on both side that needed to be merged
     Merged,
     /// Salvaged: file was candidate for deletion, but survived the merge
     Salvaged,
     /// Normal: Not one of the two cases above
     Normal,
 }
 
 const COPY_MASK: u8 = 3;
 const P1_COPY: u8 = 2;
 const P2_COPY: u8 = 3;
 const ACTION_MASK: u8 = 28;
 const REMOVED: u8 = 12;
 const MERGED: u8 = 8;
 const SALVAGED: u8 = 16;
 
 #[derive(BytesCast)]
 #[repr(C)]
 struct ChangedFilesIndexEntry {
     flags: u8,
 
     /// Only the end position is stored. The start is at the end of the
     /// previous entry.
     destination_path_end_position: unaligned::U32Be,
 
     source_index_entry_position: unaligned::U32Be,
 }
 
 fn _static_assert_size_of() {
     let _ = std::mem::transmute::<ChangedFilesIndexEntry, [u8; 9]>;
 }
 
 /// Represents the files affected by a changeset.
 ///
 /// This holds a subset of `mercurial.metadata.ChangingFiles` as we do not need
 /// all the data categories tracked by it.
 pub struct ChangedFiles<'a> {
     index: &'a [ChangedFilesIndexEntry],
     paths: &'a [u8],
 }
 
 impl<'a> ChangedFiles<'a> {
     pub fn new(data: &'a [u8]) -> Self {
         let (header, rest) = unaligned::U32Be::from_bytes(data).unwrap();
         let nb_index_entries = header.get() as usize;
         let (index, paths) =
             ChangedFilesIndexEntry::slice_from_bytes(rest, nb_index_entries)
                 .unwrap();
         Self { index, paths }
     }
 
     pub fn new_empty() -> Self {
         ChangedFiles {
             index: &[],
             paths: &[],
         }
     }
 
     /// Internal function to return the filename of the entry at a given index
     fn path(&self, idx: usize) -> &HgPath {
         let start = if idx == 0 {
             0
         } else {
             self.index[idx - 1].destination_path_end_position.get() as usize
         };
         let end = self.index[idx].destination_path_end_position.get() as usize;
         HgPath::new(&self.paths[start..end])
     }
 
     /// Return an iterator over all the `Action` in this instance.
     fn iter_actions(&self) -> impl Iterator<Item = Action> {
         self.index.iter().enumerate().flat_map(move |(idx, entry)| {
             let path = self.path(idx);
             if (entry.flags & ACTION_MASK) == REMOVED {
                 Some(Action::Removed(path))
             } else if (entry.flags & COPY_MASK) == P1_COPY {
                 let source_idx =
                     entry.source_index_entry_position.get() as usize;
                 Some(Action::CopiedFromP1(path, self.path(source_idx)))
             } else if (entry.flags & COPY_MASK) == P2_COPY {
                 let source_idx =
                     entry.source_index_entry_position.get() as usize;
                 Some(Action::CopiedFromP2(path, self.path(source_idx)))
             } else {
                 None
             }
         })
     }
 
     /// return the MergeCase value associated with a filename
     fn get_merge_case(&self, path: &HgPath) -> MergeCase {
         if self.index.is_empty() {
             return MergeCase::Normal;
         }
         let mut low_part = 0;
         let mut high_part = self.index.len();
 
         while low_part < high_part {
             let cursor = (low_part + high_part - 1) / 2;
             match path.cmp(self.path(cursor)) {
                 Ordering::Less => low_part = cursor + 1,
                 Ordering::Greater => high_part = cursor,
                 Ordering::Equal => {
                     return match self.index[cursor].flags & ACTION_MASK {
                         MERGED => MergeCase::Merged,
                         SALVAGED => MergeCase::Salvaged,
                         _ => MergeCase::Normal,
                     };
                 }
             }
         }
         MergeCase::Normal
     }
 }
 
 /// A small "tokenizer" responsible of turning full HgPath into lighter
 /// PathToken
 ///
 /// Dealing with small object, like integer is much faster, so HgPath input are
 /// turned into integer "PathToken" and converted back in the end.
 #[derive(Clone, Debug, Default)]
 struct TwoWayPathMap {
     token: HashMap<HgPathBuf, PathToken>,
     path: Vec<HgPathBuf>,
 }
 
 impl TwoWayPathMap {
     fn tokenize(&mut self, path: &HgPath) -> PathToken {
         match self.token.get(path) {
             Some(a) => *a,
             None => {
                 let a = self.token.len();
                 let buf = path.to_owned();
                 self.path.push(buf.clone());
                 self.token.insert(buf, a);
                 a
             }
         }
     }
 
     fn untokenize(&self, token: PathToken) -> &HgPathBuf {
         assert!(token < self.path.len(), "Unknown token: {}", token);
         &self.path[token]
     }
 }
 
 /// Same as mercurial.copies._combine_changeset_copies, but in Rust.
 pub struct CombineChangesetCopies {
     all_copies: HashMap<Revision, InternalPathCopies>,
     path_map: TwoWayPathMap,
     children_count: HashMap<Revision, usize>,
 }
 
 impl CombineChangesetCopies {
     pub fn new(children_count: HashMap<Revision, usize>) -> Self {
         Self {
             all_copies: HashMap::new(),
             path_map: TwoWayPathMap::default(),
             children_count,
         }
     }
 
     /// Combined the given `changes` data specific to `rev` with the data
     /// previously given for its parents (and transitively, its ancestors).
     pub fn add_revision(
         &mut self,
         rev: Revision,
         p1: Revision,
         p2: Revision,
         changes: ChangedFiles<'_>,
     ) {
         self.add_revision_inner(rev, p1, p2, changes.iter_actions(), |path| {
             changes.get_merge_case(path)
         })
     }
 
     /// Separated out from `add_revsion` so that unit tests can call this
     /// without synthetizing a `ChangedFiles` in binary format.
     fn add_revision_inner<'a>(
         &mut self,
         rev: Revision,
         p1: Revision,
         p2: Revision,
         copy_actions: impl Iterator<Item = Action<'a>>,
         get_merge_case: impl Fn(&HgPath) -> MergeCase + Copy,
     ) {
         // Retrieve data computed in a previous iteration
         let p1_copies = match p1 {
             NULL_REVISION => None,
             _ => get_and_clean_parent_copies(
                 &mut self.all_copies,
                 &mut self.children_count,
                 p1,
             ), // will be None if the vertex is not to be traversed
         };
         let p2_copies = match p2 {
             NULL_REVISION => None,
             _ => get_and_clean_parent_copies(
                 &mut self.all_copies,
                 &mut self.children_count,
                 p2,
             ), // will be None if the vertex is not to be traversed
         };
         // combine it with data for that revision
         let (p1_copies, p2_copies) = chain_changes(
             &mut self.path_map,
             p1_copies,
             p2_copies,
             copy_actions,
             rev,
         );
         let copies = match (p1_copies, p2_copies) {
             (None, None) => None,
             (c, None) => c,
             (None, c) => c,
             (Some(p1_copies), Some(p2_copies)) => Some(merge_copies_dict(
                 &self.path_map,
                 rev,
                 p2_copies,
                 p1_copies,
                 get_merge_case,
             )),
         };
         if let Some(c) = copies {
             self.all_copies.insert(rev, c);
         }
     }
 
     /// Drop intermediate data (such as which revision a copy was from) and
     /// return the final mapping.
     pub fn finish(mut self, target_rev: Revision) -> PathCopies {
         let tt_result = self
             .all_copies
             .remove(&target_rev)
             .expect("target revision was not processed");
         let mut result = PathCopies::default();
         for (dest, tt_source) in tt_result {
             if let Some(path) = tt_source.path {
                 let path_dest = self.path_map.untokenize(dest).to_owned();
                 let path_path = self.path_map.untokenize(path).to_owned();
                 result.insert(path_dest, path_path);
             }
         }
         result
     }
 }
 
 /// fetch previous computed information
 ///
 /// If no other children are expected to need this information, we drop it from
 /// the cache.
 ///
 /// If parent is not part of the set we are expected to walk, return None.
 fn get_and_clean_parent_copies(
     all_copies: &mut HashMap<Revision, InternalPathCopies>,
     children_count: &mut HashMap<Revision, usize>,
     parent_rev: Revision,
 ) -> Option<InternalPathCopies> {
     let count = children_count.get_mut(&parent_rev)?;
     *count -= 1;
     if *count == 0 {
         match all_copies.remove(&parent_rev) {
             Some(c) => Some(c),
             None => Some(InternalPathCopies::default()),
         }
     } else {
         match all_copies.get(&parent_rev) {
             Some(c) => Some(c.clone()),
             None => Some(InternalPathCopies::default()),
         }
     }
 }
 
 /// Combine ChangedFiles with some existing PathCopies information and return
 /// the result
 fn chain_changes<'a>(
     path_map: &mut TwoWayPathMap,
     base_p1_copies: Option<InternalPathCopies>,
     base_p2_copies: Option<InternalPathCopies>,
     copy_actions: impl Iterator<Item = Action<'a>>,
     current_rev: Revision,
 ) -> (Option<InternalPathCopies>, Option<InternalPathCopies>) {
     // Fast path the "nothing to do" case.
     if let (None, None) = (&base_p1_copies, &base_p2_copies) {
         return (None, None);
     }
 
     let mut p1_copies = base_p1_copies.clone();
     let mut p2_copies = base_p2_copies.clone();
     for action in copy_actions {
         match action {
             Action::CopiedFromP1(path_dest, path_source) => {
                 match &mut p1_copies {
                     None => (), // This is not a vertex we should proceed.
                     Some(copies) => add_one_copy(
                         current_rev,
                         path_map,
                         copies,
                         base_p1_copies.as_ref().unwrap(),
                         path_dest,
                         path_source,
                     ),
                 }
             }
             Action::CopiedFromP2(path_dest, path_source) => {
                 match &mut p2_copies {
                     None => (), // This is not a vertex we should proceed.
                     Some(copies) => add_one_copy(
                         current_rev,
                         path_map,
                         copies,
                         base_p2_copies.as_ref().unwrap(),
                         path_dest,
                         path_source,
                     ),
                 }
             }
             Action::Removed(deleted_path) => {
                 // We must drop copy information for removed file.
                 //
                 // We need to explicitly record them as dropped to
                 // propagate this information when merging two
                 // InternalPathCopies object.
                 let deleted = path_map.tokenize(deleted_path);
 
                 let p1_entry = match &mut p1_copies {
                     None => None,
                     Some(copies) => match copies.entry(deleted) {
                         Entry::Occupied(e) => Some(e),
                         Entry::Vacant(_) => None,
                     },
                 };
                 let p2_entry = match &mut p2_copies {
                     None => None,
                     Some(copies) => match copies.entry(deleted) {
                         Entry::Occupied(e) => Some(e),
                         Entry::Vacant(_) => None,
                     },
                 };
 
                 match (p1_entry, p2_entry) {
                     (None, None) => (),
                     (Some(mut e), None) => {
                         e.get_mut().mark_delete(current_rev)
                     }
                     (None, Some(mut e)) => {
                         e.get_mut().mark_delete(current_rev)
                     }
                     (Some(mut e1), Some(mut e2)) => {
                         let cs1 = e1.get_mut();
                         let cs2 = e2.get();
                         if cs1 == cs2 {
                             cs1.mark_delete(current_rev);
                         } else {
-                            cs1.mark_delete_with_pair(current_rev, &cs2);
+                            cs1.mark_delete_with_pair(current_rev, cs2);
                         }
                         e2.insert(cs1.clone());
                     }
                 }
             }
         }
     }
     (p1_copies, p2_copies)
 }
 
 // insert one new copy information in an InternalPathCopies
 //
 // This deal with chaining and overwrite.
 fn add_one_copy(
     current_rev: Revision,
     path_map: &mut TwoWayPathMap,
     copies: &mut InternalPathCopies,
     base_copies: &InternalPathCopies,
     path_dest: &HgPath,
     path_source: &HgPath,
 ) {
     let dest = path_map.tokenize(path_dest);
     let source = path_map.tokenize(path_source);
-    let entry;
-    if let Some(v) = base_copies.get(&source) {
-        entry = match &v.path {
+    let entry = if let Some(v) = base_copies.get(&source) {
+        match &v.path {
             Some(path) => Some((*(path)).to_owned()),
             None => Some(source.to_owned()),
         }
     } else {
-        entry = Some(source.to_owned());
-    }
+        Some(source.to_owned())
+    };
     // Each new entry is introduced by the children, we
     // record this information as we will need it to take
     // the right decision when merging conflicting copy
     // information. See merge_copies_dict for details.
     match copies.entry(dest) {
         Entry::Vacant(slot) => {
             let ttpc = CopySource::new(current_rev, entry);
             slot.insert(ttpc);
         }
         Entry::Occupied(mut slot) => {
             let ttpc = slot.get_mut();
             ttpc.overwrite(current_rev, entry);
         }
     }
 }
 
 /// merge two copies-mapping together, minor and major
 ///
 /// In case of conflict, value from "major" will be picked, unless in some
 /// cases. See inline documentation for details.
 fn merge_copies_dict(
     path_map: &TwoWayPathMap,
     current_merge: Revision,
     minor: InternalPathCopies,
     major: InternalPathCopies,
     get_merge_case: impl Fn(&HgPath) -> MergeCase + Copy,
 ) -> InternalPathCopies {
     use crate::utils::{ordmap_union_with_merge, MergeResult};
 
     ordmap_union_with_merge(minor, major, |&dest, src_minor, src_major| {
         let (pick, overwrite) = compare_value(
             current_merge,
             || get_merge_case(path_map.untokenize(dest)),
             src_minor,
             src_major,
         );
         if overwrite {
             let (winner, loser) = match pick {
                 MergePick::Major | MergePick::Any => (src_major, src_minor),
                 MergePick::Minor => (src_minor, src_major),
             };
-            MergeResult::UseNewValue(CopySource::new_from_merge(
+            MergeResult::NewValue(CopySource::new_from_merge(
                 current_merge,
                 winner,
                 loser,
             ))
         } else {
             match pick {
-                MergePick::Any | MergePick::Major => {
-                    MergeResult::UseRightValue
-                }
-                MergePick::Minor => MergeResult::UseLeftValue,
+                MergePick::Any | MergePick::Major => MergeResult::RightValue,
+                MergePick::Minor => MergeResult::LeftValue,
             }
         }
     })
 }
 
 /// represent the side that should prevail when merging two
 /// InternalPathCopies
 #[derive(Debug, PartialEq)]
 enum MergePick {
     /// The "major" (p1) side prevails
     Major,
     /// The "minor" (p2) side prevails
     Minor,
     /// Any side could be used (because they are the same)
     Any,
 }
 
 /// decide which side prevails in case of conflicting values
 #[allow(clippy::if_same_then_else)]
 fn compare_value(
     current_merge: Revision,
     merge_case_for_dest: impl Fn() -> MergeCase,
     src_minor: &CopySource,
     src_major: &CopySource,
 ) -> (MergePick, bool) {
     if src_major == src_minor {
         (MergePick::Any, false)
     } else if src_major.rev == current_merge {
         // minor is different according to per minor == major check earlier
         debug_assert!(src_minor.rev != current_merge);
 
         // The last value comes the current merge, this value -will- win
         // eventually.
         (MergePick::Major, true)
     } else if src_minor.rev == current_merge {
         // The last value comes the current merge, this value -will- win
         // eventually.
         (MergePick::Minor, true)
     } else if src_major.path == src_minor.path {
         debug_assert!(src_major.rev != src_minor.rev);
         // we have the same value, but from other source;
         if src_major.is_overwritten_by(src_minor) {
             (MergePick::Minor, false)
         } else if src_minor.is_overwritten_by(src_major) {
             (MergePick::Major, false)
         } else {
             (MergePick::Any, true)
         }
     } else {
         debug_assert!(src_major.rev != src_minor.rev);
         let action = merge_case_for_dest();
         if src_minor.path.is_some()
             && src_major.path.is_none()
             && action == MergeCase::Salvaged
         {
             // If the file is "deleted" in the major side but was
             // salvaged by the merge, we keep the minor side alive
             (MergePick::Minor, true)
         } else if src_major.path.is_some()
             && src_minor.path.is_none()
             && action == MergeCase::Salvaged
         {
             // If the file is "deleted" in the minor side but was
             // salvaged by the merge, unconditionnaly preserve the
             // major side.
             (MergePick::Major, true)
         } else if src_minor.is_overwritten_by(src_major) {
             // The information from the minor version are strictly older than
             // the major version
             if action == MergeCase::Merged {
                 // If the file was actively merged, its means some non-copy
                 // activity happened on the other branch. It
                 // mean the older copy information are still relevant.
                 //
                 // The major side wins such conflict.
                 (MergePick::Major, true)
             } else {
                 // No activity on the minor branch, pick the newer one.
                 (MergePick::Major, false)
             }
         } else if src_major.is_overwritten_by(src_minor) {
             if action == MergeCase::Merged {
                 // If the file was actively merged, its means some non-copy
                 // activity happened on the other branch. It
                 // mean the older copy information are still relevant.
                 //
                 // The major side wins such conflict.
                 (MergePick::Major, true)
             } else {
                 // No activity on the minor branch, pick the newer one.
                 (MergePick::Minor, false)
             }
         } else if src_minor.path.is_none() {
             // the minor side has no relevant information, pick the alive one
             (MergePick::Major, true)
         } else if src_major.path.is_none() {
             // the major side has no relevant information, pick the alive one
             (MergePick::Minor, true)
         } else {
             // by default the major side wins
             (MergePick::Major, true)
         }
     }
 }

rust/hg-core/src/dagops.rs

@@ -1,276 +1,276 b''
 // dagops.rs
 //
 // Copyright 2019 Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Miscellaneous DAG operations
 //!
 //! # Terminology
 //! - By *relative heads* of a collection of revision numbers (`Revision`), we
 //!   mean those revisions that have no children among the collection.
 //! - Similarly *relative roots* of a collection of `Revision`, we mean those
 //!   whose parents, if any, don't belong to the collection.
 use super::{Graph, GraphError, Revision, NULL_REVISION};
 use crate::ancestors::AncestorsIterator;
 use std::collections::{BTreeSet, HashSet};
 
 fn remove_parents<S: std::hash::BuildHasher>(
     graph: &impl Graph,
     rev: Revision,
     set: &mut HashSet<Revision, S>,
 ) -> Result<(), GraphError> {
     for parent in graph.parents(rev)?.iter() {
         if *parent != NULL_REVISION {
             set.remove(parent);
         }
     }
     Ok(())
 }
 
 /// Relative heads out of some revisions, passed as an iterator.
 ///
 /// These heads are defined as those revisions that have no children
 /// among those emitted by the iterator.
 ///
 /// # Performance notes
 /// Internally, this clones the iterator, and builds a `HashSet` out of it.
 ///
 /// This function takes an `Iterator` instead of `impl IntoIterator` to
 /// guarantee that cloning the iterator doesn't result in cloning the full
 /// construct it comes from.
 pub fn heads<'a>(
     graph: &impl Graph,
     iter_revs: impl Clone + Iterator<Item = &'a Revision>,
 ) -> Result<HashSet<Revision>, GraphError> {
     let mut heads: HashSet<Revision> = iter_revs.clone().cloned().collect();
     heads.remove(&NULL_REVISION);
     for rev in iter_revs {
         if *rev != NULL_REVISION {
             remove_parents(graph, *rev, &mut heads)?;
         }
     }
     Ok(heads)
 }
 
 /// Retain in `revs` only its relative heads.
 ///
 /// This is an in-place operation, so that control of the incoming
 /// set is left to the caller.
 /// - 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
 ///   heads.
 /// - a Rust caller can decide whether cloning beforehand is appropriate
 ///
 /// # Performance notes
 /// Internally, this function will store a full copy of `revs` in a `Vec`.
 pub fn retain_heads<S: std::hash::BuildHasher>(
     graph: &impl Graph,
     revs: &mut HashSet<Revision, S>,
 ) -> Result<(), GraphError> {
     revs.remove(&NULL_REVISION);
     // we need to construct an iterable copy of revs to avoid itering while
     // mutating
     let as_vec: Vec<Revision> = revs.iter().cloned().collect();
     for rev in as_vec {
         if rev != NULL_REVISION {
             remove_parents(graph, rev, revs)?;
         }
     }
     Ok(())
 }
 
 /// Roots of `revs`, passed as a `HashSet`
 ///
 /// They are returned in arbitrary order
 pub fn roots<G: Graph, S: std::hash::BuildHasher>(
     graph: &G,
     revs: &HashSet<Revision, S>,
 ) -> Result<Vec<Revision>, GraphError> {
     let mut roots: Vec<Revision> = Vec::new();
     for rev in revs {
         if graph
             .parents(*rev)?
             .iter()
             .filter(|p| **p != NULL_REVISION)
             .all(|p| !revs.contains(p))
         {
             roots.push(*rev);
         }
     }
     Ok(roots)
 }
 
 /// Compute the topological range between two collections of revisions
 ///
 /// This is equivalent to the revset `<roots>::<heads>`.
 ///
 /// Currently, the given `Graph` has to implement `Clone`, which means
 /// actually cloning just a reference-counted Python pointer if
 /// it's passed over through `rust-cpython`. This is due to the internal
 /// use of `AncestorsIterator`
 ///
 /// # Algorithmic details
 ///
 /// This is a two-pass swipe inspired from what `reachableroots2` from
 /// `mercurial.cext.parsers` does to obtain the same results.
 ///
 /// - first, we climb up the DAG from `heads` in topological order, keeping
 ///   them in the vector `heads_ancestors` vector, and adding any element of
 ///   `roots` we find among them to the resulting range.
 /// - Then, we iterate on that recorded vector so that a revision is always
 ///   emitted after its parents and add all revisions whose parents are already
 ///   in the range to the results.
 ///
 /// # Performance notes
 ///
 /// The main difference with the C implementation is that
 /// the latter uses a flat array with bit flags, instead of complex structures
 /// like `HashSet`, making it faster in most scenarios. In theory, it's
 /// possible that the present implementation could be more memory efficient
 /// for very large repositories with many branches.
 pub fn range(
     graph: &(impl Graph + Clone),
     roots: impl IntoIterator<Item = Revision>,
     heads: impl IntoIterator<Item = Revision>,
 ) -> Result<BTreeSet<Revision>, GraphError> {
     let mut range = BTreeSet::new();
     let roots: HashSet<Revision> = roots.into_iter().collect();
     let min_root: Revision = match roots.iter().cloned().min() {
         None => {
             return Ok(range);
         }
         Some(r) => r,
     };
 
     // Internally, AncestorsIterator currently maintains a `HashSet`
     // of all seen revision, which is also what we record, albeit in an ordered
     // way. There's room for improvement on this duplication.
     let ait = AncestorsIterator::new(graph.clone(), heads, min_root, true)?;
     let mut heads_ancestors: Vec<Revision> = Vec::new();
     for revres in ait {
         let rev = revres?;
         if roots.contains(&rev) {
             range.insert(rev);
         }
         heads_ancestors.push(rev);
     }
 
     for rev in heads_ancestors.into_iter().rev() {
         for parent in graph.parents(rev)?.iter() {
             if *parent != NULL_REVISION && range.contains(parent) {
                 range.insert(rev);
             }
         }
     }
     Ok(range)
 }
 
 #[cfg(test)]
 mod tests {
 
     use super::*;
     use crate::testing::SampleGraph;
 
     /// Apply `retain_heads()` to the given slice and return as a sorted `Vec`
     fn retain_heads_sorted(
         graph: &impl Graph,
         revs: &[Revision],
     ) -> Result<Vec<Revision>, GraphError> {
         let mut revs: HashSet<Revision> = revs.iter().cloned().collect();
         retain_heads(graph, &mut revs)?;
         let mut as_vec: Vec<Revision> = revs.iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         Ok(as_vec)
     }
 
     #[test]
     fn test_retain_heads() -> Result<(), GraphError> {
         assert_eq!(retain_heads_sorted(&SampleGraph, &[4, 5, 6])?, vec![5, 6]);
         assert_eq!(
             retain_heads_sorted(&SampleGraph, &[4, 1, 6, 12, 0])?,
             vec![1, 6, 12]
         );
         assert_eq!(
             retain_heads_sorted(&SampleGraph, &[1, 2, 3, 4, 5, 6, 7, 8, 9])?,
             vec![3, 5, 8, 9]
         );
         Ok(())
     }
 
     /// Apply `heads()` to the given slice and return as a sorted `Vec`
     fn heads_sorted(
         graph: &impl Graph,
         revs: &[Revision],
     ) -> Result<Vec<Revision>, GraphError> {
         let heads = heads(graph, revs.iter())?;
         let mut as_vec: Vec<Revision> = heads.iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         Ok(as_vec)
     }
 
     #[test]
     fn test_heads() -> Result<(), GraphError> {
         assert_eq!(heads_sorted(&SampleGraph, &[4, 5, 6])?, vec![5, 6]);
         assert_eq!(
             heads_sorted(&SampleGraph, &[4, 1, 6, 12, 0])?,
             vec![1, 6, 12]
         );
         assert_eq!(
             heads_sorted(&SampleGraph, &[1, 2, 3, 4, 5, 6, 7, 8, 9])?,
             vec![3, 5, 8, 9]
         );
         Ok(())
     }
 
     /// Apply `roots()` and sort the result for easier comparison
     fn roots_sorted(
         graph: &impl Graph,
         revs: &[Revision],
     ) -> Result<Vec<Revision>, GraphError> {
         let set: HashSet<_> = revs.iter().cloned().collect();
         let mut as_vec = roots(graph, &set)?;
-        as_vec.sort();
+        as_vec.sort_unstable();
         Ok(as_vec)
     }
 
     #[test]
     fn test_roots() -> Result<(), GraphError> {
         assert_eq!(roots_sorted(&SampleGraph, &[4, 5, 6])?, vec![4]);
         assert_eq!(
             roots_sorted(&SampleGraph, &[4, 1, 6, 12, 0])?,
             vec![0, 4, 12]
         );
         assert_eq!(
             roots_sorted(&SampleGraph, &[1, 2, 3, 4, 5, 6, 7, 8, 9])?,
             vec![1, 8]
         );
         Ok(())
     }
 
     /// Apply `range()` and convert the result into a Vec for easier comparison
     fn range_vec(
         graph: impl Graph + Clone,
         roots: &[Revision],
         heads: &[Revision],
     ) -> Result<Vec<Revision>, GraphError> {
         range(&graph, roots.iter().cloned(), heads.iter().cloned())
             .map(|bs| bs.into_iter().collect())
     }
 
     #[test]
     fn test_range() -> Result<(), GraphError> {
         assert_eq!(range_vec(SampleGraph, &[0], &[4])?, vec![0, 1, 2, 4]);
         assert_eq!(range_vec(SampleGraph, &[0], &[8])?, vec![]);
         assert_eq!(
             range_vec(SampleGraph, &[5, 6], &[10, 11, 13])?,
             vec![5, 10]
         );
         assert_eq!(
             range_vec(SampleGraph, &[5, 6], &[10, 12])?,
             vec![5, 6, 9, 10, 12]
         );
         Ok(())
     }
 }

rust/hg-core/src/dirstate.rs

@@ -1,50 +1,50 b''
 // dirstate module
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::revlog::node::NULL_NODE;
 use crate::revlog::Node;
 use crate::utils::hg_path::HgPath;
 use bytes_cast::BytesCast;
 
 pub mod dirs_multiset;
 pub mod entry;
 pub mod parsers;
 pub mod status;
 
 pub use self::entry::*;
 
 #[derive(Debug, PartialEq, Copy, Clone, BytesCast)]
 #[repr(C)]
 pub struct DirstateParents {
     pub p1: Node,
     pub p2: Node,
 }
 
 impl DirstateParents {
     pub const NULL: Self = Self {
         p1: NULL_NODE,
         p2: NULL_NODE,
     };
 
     pub fn is_merge(&self) -> bool {
-        return !(self.p2 == NULL_NODE);
+        !(self.p2 == NULL_NODE)
     }
 }
 
 pub type StateMapIter<'a> = Box<
     dyn Iterator<
             Item = Result<(&'a HgPath, DirstateEntry), DirstateV2ParseError>,
         > + Send
         + 'a,
 >;
 
 pub type CopyMapIter<'a> = Box<
     dyn Iterator<Item = Result<(&'a HgPath, &'a HgPath), DirstateV2ParseError>>
         + Send
         + 'a,
 >;

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

@@ -1,418 +1,418 b''
 // dirs_multiset.rs
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! A multiset of directory names.
 //!
 //! Used to counts the references to directories in a manifest or dirstate.
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::{
     utils::{
         files,
         hg_path::{HgPath, HgPathBuf, HgPathError},
     },
     DirstateEntry, DirstateError, DirstateMapError, FastHashMap,
 };
 use std::collections::{hash_map, hash_map::Entry, HashMap, HashSet};
 
 // could be encapsulated if we care API stability more seriously
 pub type DirsMultisetIter<'a> = hash_map::Keys<'a, HgPathBuf, u32>;
 
 #[derive(PartialEq, Debug)]
 pub struct DirsMultiset {
     inner: FastHashMap<HgPathBuf, u32>,
 }
 
 impl DirsMultiset {
     /// Initializes the multiset from a dirstate.
     ///
     /// If `skip_state` is provided, skips dirstate entries with equal state.
     pub fn from_dirstate<I, P>(
         dirstate: I,
         only_tracked: bool,
     ) -> Result<Self, DirstateError>
     where
         I: IntoIterator<
             Item = Result<(P, DirstateEntry), DirstateV2ParseError>,
         >,
         P: AsRef<HgPath>,
     {
         let mut multiset = DirsMultiset {
             inner: FastHashMap::default(),
         };
         for item in dirstate {
             let (filename, entry) = item?;
             let filename = filename.as_ref();
             // This `if` is optimized out of the loop
             if only_tracked {
                 if !entry.removed() {
                     multiset.add_path(filename)?;
                 }
             } else {
                 multiset.add_path(filename)?;
             }
         }
 
         Ok(multiset)
     }
 
     /// Initializes the multiset from a manifest.
     pub fn from_manifest(
         manifest: &[impl AsRef<HgPath>],
     ) -> Result<Self, DirstateMapError> {
         let mut multiset = DirsMultiset {
             inner: FastHashMap::default(),
         };
 
         for filename in manifest {
             multiset.add_path(filename.as_ref())?;
         }
 
         Ok(multiset)
     }
 
     /// Increases the count of deepest directory contained in the path.
     ///
     /// If the directory is not yet in the map, adds its parents.
     pub fn add_path(
         &mut self,
         path: impl AsRef<HgPath>,
     ) -> Result<(), DirstateMapError> {
         for subpath in files::find_dirs(path.as_ref()) {
             if subpath.as_bytes().last() == Some(&b'/') {
                 // TODO Remove this once PathAuditor is certified
                 // as the only entrypoint for path data
                 let second_slash_index = subpath.len() - 1;
 
                 return Err(DirstateMapError::InvalidPath(
                     HgPathError::ConsecutiveSlashes {
                         bytes: path.as_ref().as_bytes().to_owned(),
                         second_slash_index,
                     },
                 ));
             }
             if let Some(val) = self.inner.get_mut(subpath) {
                 *val += 1;
                 break;
             }
             self.inner.insert(subpath.to_owned(), 1);
         }
         Ok(())
     }
 
     /// Decreases the count of deepest directory contained in the path.
     ///
     /// If it is the only reference, decreases all parents until one is
     /// removed.
     /// If the directory is not in the map, something horrible has happened.
     pub fn delete_path(
         &mut self,
         path: impl AsRef<HgPath>,
     ) -> Result<(), DirstateMapError> {
         for subpath in files::find_dirs(path.as_ref()) {
             match self.inner.entry(subpath.to_owned()) {
                 Entry::Occupied(mut entry) => {
                     let val = *entry.get();
                     if val > 1 {
                         entry.insert(val - 1);
                         break;
                     }
                     entry.remove();
                 }
                 Entry::Vacant(_) => {
                     return Err(DirstateMapError::PathNotFound(
                         path.as_ref().to_owned(),
                     ))
                 }
             };
         }
 
         Ok(())
     }
 
     pub fn contains(&self, key: impl AsRef<HgPath>) -> bool {
         self.inner.contains_key(key.as_ref())
     }
 
     pub fn iter(&self) -> DirsMultisetIter {
         self.inner.keys()
     }
 
     pub fn len(&self) -> usize {
         self.inner.len()
     }
 
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 }
 
 /// This is basically a reimplementation of `DirsMultiset` that stores the
 /// children instead of just a count of them, plus a small optional
 /// optimization to avoid some directories we don't need.
 #[derive(PartialEq, Debug)]
 pub struct DirsChildrenMultiset<'a> {
     inner: FastHashMap<&'a HgPath, HashSet<&'a HgPath>>,
     only_include: Option<HashSet<&'a HgPath>>,
 }
 
 impl<'a> DirsChildrenMultiset<'a> {
     pub fn new(
         paths: impl Iterator<Item = &'a HgPathBuf>,
         only_include: Option<&'a HashSet<impl AsRef<HgPath> + 'a>>,
     ) -> Self {
         let mut new = Self {
             inner: HashMap::default(),
             only_include: only_include
                 .map(|s| s.iter().map(AsRef::as_ref).collect()),
         };
 
         for path in paths {
             new.add_path(path)
         }
 
         new
     }
     fn add_path(&mut self, path: &'a (impl AsRef<HgPath> + 'a)) {
         if path.as_ref().is_empty() {
             return;
         }
         for (directory, basename) in files::find_dirs_with_base(path.as_ref())
         {
             if !self.is_dir_included(directory) {
                 continue;
             }
             self.inner
                 .entry(directory)
                 .and_modify(|e| {
                     e.insert(basename);
                 })
                 .or_insert_with(|| {
                     let mut set = HashSet::new();
                     set.insert(basename);
                     set
                 });
         }
     }
     fn is_dir_included(&self, dir: impl AsRef<HgPath>) -> bool {
         match &self.only_include {
             None => false,
             Some(i) => i.contains(dir.as_ref()),
         }
     }
 
     pub fn get(
         &self,
         path: impl AsRef<HgPath>,
     ) -> Option<&HashSet<&'a HgPath>> {
         self.inner.get(path.as_ref())
     }
 }
 
 #[cfg(test)]
 mod tests {
     use crate::EntryState;
 
     use super::*;
 
     #[test]
     fn test_delete_path_path_not_found() {
         let manifest: Vec<HgPathBuf> = vec![];
         let mut map = DirsMultiset::from_manifest(&manifest).unwrap();
         let path = HgPathBuf::from_bytes(b"doesnotexist/");
         assert_eq!(
             Err(DirstateMapError::PathNotFound(path.to_owned())),
             map.delete_path(&path)
         );
     }
 
     #[test]
     fn test_delete_path_empty_path() {
         let mut map =
-            DirsMultiset::from_manifest(&vec![HgPathBuf::new()]).unwrap();
+            DirsMultiset::from_manifest(&[HgPathBuf::new()]).unwrap();
         let path = HgPath::new(b"");
         assert_eq!(Ok(()), map.delete_path(path));
         assert_eq!(
             Err(DirstateMapError::PathNotFound(path.to_owned())),
             map.delete_path(path)
         );
     }
 
     #[test]
     fn test_delete_path_successful() {
         let mut map = DirsMultiset {
             inner: [("", 5), ("a", 3), ("a/b", 2), ("a/c", 1)]
                 .iter()
                 .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
                 .collect(),
         };
 
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/b/")));
         eprintln!("{:?}", map);
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/b/")));
         eprintln!("{:?}", map);
         assert_eq!(
             Err(DirstateMapError::PathNotFound(HgPathBuf::from_bytes(
                 b"a/b/"
             ))),
             map.delete_path(HgPath::new(b"a/b/"))
         );
 
         assert_eq!(2, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(1, *map.inner.get(HgPath::new(b"a/c")).unwrap());
         eprintln!("{:?}", map);
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/")));
         eprintln!("{:?}", map);
 
         assert_eq!(Ok(()), map.delete_path(HgPath::new(b"a/c/")));
         assert_eq!(
             Err(DirstateMapError::PathNotFound(HgPathBuf::from_bytes(
                 b"a/c/"
             ))),
             map.delete_path(HgPath::new(b"a/c/"))
         );
     }
 
     #[test]
     fn test_add_path_empty_path() {
         let manifest: Vec<HgPathBuf> = vec![];
         let mut map = DirsMultiset::from_manifest(&manifest).unwrap();
         let path = HgPath::new(b"");
         map.add_path(path).unwrap();
 
         assert_eq!(1, map.len());
     }
 
     #[test]
     fn test_add_path_successful() {
         let manifest: Vec<HgPathBuf> = vec![];
         let mut map = DirsMultiset::from_manifest(&manifest).unwrap();
 
         map.add_path(HgPath::new(b"a/")).unwrap();
         assert_eq!(1, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(1, *map.inner.get(HgPath::new(b"")).unwrap());
         assert_eq!(2, map.len());
 
         // Non directory should be ignored
         map.add_path(HgPath::new(b"a")).unwrap();
         assert_eq!(1, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(2, map.len());
 
         // Non directory will still add its base
         map.add_path(HgPath::new(b"a/b")).unwrap();
         assert_eq!(2, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(2, map.len());
 
         // Duplicate path works
         map.add_path(HgPath::new(b"a/")).unwrap();
         assert_eq!(3, *map.inner.get(HgPath::new(b"a")).unwrap());
 
         // Nested dir adds to its base
         map.add_path(HgPath::new(b"a/b/")).unwrap();
         assert_eq!(4, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(1, *map.inner.get(HgPath::new(b"a/b")).unwrap());
 
         // but not its base's base, because it already existed
         map.add_path(HgPath::new(b"a/b/c/")).unwrap();
         assert_eq!(4, *map.inner.get(HgPath::new(b"a")).unwrap());
         assert_eq!(2, *map.inner.get(HgPath::new(b"a/b")).unwrap());
 
         map.add_path(HgPath::new(b"a/c/")).unwrap();
         assert_eq!(1, *map.inner.get(HgPath::new(b"a/c")).unwrap());
 
         let expected = DirsMultiset {
             inner: [("", 2), ("a", 5), ("a/b", 2), ("a/b/c", 1), ("a/c", 1)]
                 .iter()
                 .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
                 .collect(),
         };
         assert_eq!(map, expected);
     }
 
     #[test]
     fn test_dirsmultiset_new_empty() {
         let manifest: Vec<HgPathBuf> = vec![];
         let new = DirsMultiset::from_manifest(&manifest).unwrap();
         let expected = DirsMultiset {
             inner: FastHashMap::default(),
         };
         assert_eq!(expected, new);
 
         let new = DirsMultiset::from_dirstate::<_, HgPathBuf>(
             std::iter::empty(),
             false,
         )
         .unwrap();
         let expected = DirsMultiset {
             inner: FastHashMap::default(),
         };
         assert_eq!(expected, new);
     }
 
     #[test]
     fn test_dirsmultiset_new_no_skip() {
         let input_vec: Vec<HgPathBuf> = ["a/", "b/", "a/c", "a/d/"]
             .iter()
             .map(|e| HgPathBuf::from_bytes(e.as_bytes()))
             .collect();
         let expected_inner = [("", 2), ("a", 3), ("b", 1), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
             .collect();
 
         let new = DirsMultiset::from_manifest(&input_vec).unwrap();
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
 
         let input_map = ["b/x", "a/c", "a/d/x"].iter().map(|f| {
             Ok((
                 HgPathBuf::from_bytes(f.as_bytes()),
                 DirstateEntry::from_v1_data(EntryState::Normal, 0, 0, 0),
             ))
         });
         let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)]
             .iter()
             .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
             .collect();
 
         let new = DirsMultiset::from_dirstate(input_map, false).unwrap();
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
     }
 
     #[test]
     fn test_dirsmultiset_new_skip() {
         let input_map = [
             ("a/", EntryState::Normal),
             ("a/b", EntryState::Normal),
             ("a/c", EntryState::Removed),
             ("a/d", EntryState::Merged),
         ]
         .iter()
         .map(|(f, state)| {
             Ok((
                 HgPathBuf::from_bytes(f.as_bytes()),
                 DirstateEntry::from_v1_data(*state, 0, 0, 0),
             ))
         });
 
         // "a" incremented with "a/c" and "a/d/"
         let expected_inner = [("", 1), ("a", 3)]
             .iter()
             .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
             .collect();
 
         let new = DirsMultiset::from_dirstate(input_map, true).unwrap();
         let expected = DirsMultiset {
             inner: expected_inner,
         };
         assert_eq!(expected, new);
     }
 }

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

@@ -1,726 +1,722 b''
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::errors::HgError;
 use bitflags::bitflags;
 use std::fs;
 use std::io;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum EntryState {
     Normal,
     Added,
     Removed,
     Merged,
 }
 
 /// `size` and `mtime.seconds` are truncated to 31 bits.
 ///
 /// TODO: double-check status algorithm correctness for files
 /// larger than 2 GiB or modified after 2038.
 #[derive(Debug, Copy, Clone)]
 pub struct DirstateEntry {
     pub(crate) flags: Flags,
     mode_size: Option<(u32, u32)>,
     mtime: Option<TruncatedTimestamp>,
 }
 
 bitflags! {
     pub(crate) struct Flags: u8 {
         const WDIR_TRACKED = 1 << 0;
         const P1_TRACKED = 1 << 1;
         const P2_INFO = 1 << 2;
         const HAS_FALLBACK_EXEC = 1 << 3;
         const FALLBACK_EXEC = 1 << 4;
         const HAS_FALLBACK_SYMLINK = 1 << 5;
         const FALLBACK_SYMLINK = 1 << 6;
     }
 }
 
 /// A Unix timestamp with nanoseconds precision
 #[derive(Debug, Copy, Clone)]
 pub struct TruncatedTimestamp {
     truncated_seconds: u32,
     /// Always in the `0 .. 1_000_000_000` range.
     nanoseconds: u32,
     /// TODO this should be in DirstateEntry, but the current code needs
     /// refactoring to use DirstateEntry instead of TruncatedTimestamp for
     /// comparison.
     pub second_ambiguous: bool,
 }
 
 impl TruncatedTimestamp {
     /// Constructs from a timestamp potentially outside of the supported range,
     /// and truncate the seconds components to its lower 31 bits.
     ///
     /// Panics if the nanoseconds components is not in the expected range.
     pub fn new_truncate(
         seconds: i64,
         nanoseconds: u32,
         second_ambiguous: bool,
     ) -> Self {
         assert!(nanoseconds < NSEC_PER_SEC);
         Self {
             truncated_seconds: seconds as u32 & RANGE_MASK_31BIT,
             nanoseconds,
             second_ambiguous,
         }
     }
 
     /// Construct from components. Returns an error if they are not in the
     /// expcted range.
     pub fn from_already_truncated(
         truncated_seconds: u32,
         nanoseconds: u32,
         second_ambiguous: bool,
     ) -> Result<Self, DirstateV2ParseError> {
         if truncated_seconds & !RANGE_MASK_31BIT == 0
             && nanoseconds < NSEC_PER_SEC
         {
             Ok(Self {
                 truncated_seconds,
                 nanoseconds,
                 second_ambiguous,
             })
         } else {
             Err(DirstateV2ParseError::new("when reading datetime"))
         }
     }
 
     /// Returns a `TruncatedTimestamp` for the modification time of `metadata`.
     ///
     /// Propagates errors from `std` on platforms where modification time
     /// is not available at all.
     pub fn for_mtime_of(metadata: &fs::Metadata) -> io::Result<Self> {
         #[cfg(unix)]
         {
             use std::os::unix::fs::MetadataExt;
             let seconds = metadata.mtime();
             // i64 -> u32 with value always in the `0 .. NSEC_PER_SEC` range
             let nanoseconds = metadata.mtime_nsec().try_into().unwrap();
             Ok(Self::new_truncate(seconds, nanoseconds, false))
         }
         #[cfg(not(unix))]
         {
             metadata.modified().map(Self::from)
         }
     }
 
     /// Like `for_mtime_of`, but may return `None` or a value with
     /// `second_ambiguous` set if the mtime is not "reliable".
     ///
     /// A modification time is reliable if it is older than `boundary` (or
     /// sufficiently in the future).
     ///
     /// Otherwise a concurrent modification might happens with the same mtime.
     pub fn for_reliable_mtime_of(
         metadata: &fs::Metadata,
         boundary: &Self,
     ) -> io::Result<Option<Self>> {
         let mut mtime = Self::for_mtime_of(metadata)?;
         // If the mtime of the ambiguous file is younger (or equal) to the
         // starting point of the `status` walk, we cannot garantee that
         // another, racy, write will not happen right after with the same mtime
         // and we cannot cache the information.
         //
         // However if the mtime is far away in the future, this is likely some
         // mismatch between the current clock and previous file system
         // operation. So mtime more than one days in the future are considered
         // fine.
         let reliable = if mtime.truncated_seconds == boundary.truncated_seconds
         {
             mtime.second_ambiguous = true;
             mtime.nanoseconds != 0
                 && boundary.nanoseconds != 0
                 && mtime.nanoseconds < boundary.nanoseconds
         } else {
             // `truncated_seconds` is less than 2**31,
             // so this does not overflow `u32`:
             let one_day_later = boundary.truncated_seconds + 24 * 3600;
             mtime.truncated_seconds < boundary.truncated_seconds
                 || mtime.truncated_seconds > one_day_later
         };
         if reliable {
             Ok(Some(mtime))
         } else {
             Ok(None)
         }
     }
 
     /// The lower 31 bits of the number of seconds since the epoch.
     pub fn truncated_seconds(&self) -> u32 {
         self.truncated_seconds
     }
 
     /// The sub-second component of this timestamp, in nanoseconds.
     /// Always in the `0 .. 1_000_000_000` range.
     ///
     /// This timestamp is after `(seconds, 0)` by this many nanoseconds.
     pub fn nanoseconds(&self) -> u32 {
         self.nanoseconds
     }
 
     /// Returns whether two timestamps are equal modulo 2**31 seconds.
     ///
     /// If this returns `true`, the original values converted from `SystemTime`
     /// or given to `new_truncate` were very likely equal. A false positive is
     /// possible if they were exactly a multiple of 2**31 seconds apart (around
     /// 68 years). This is deemed very unlikely to happen by chance, especially
     /// on filesystems that support sub-second precision.
     ///
     /// If someone is manipulating the modification times of some files to
     /// intentionally make `hg status` return incorrect results, not truncating
     /// wouldn’t help much since they can set exactly the expected timestamp.
     ///
     /// Sub-second precision is ignored if it is zero in either value.
     /// Some APIs simply return zero when more precision is not available.
     /// When comparing values from different sources, if only one is truncated
     /// in that way, doing a simple comparison would cause many false
     /// negatives.
     pub fn likely_equal(self, other: Self) -> bool {
         if self.truncated_seconds != other.truncated_seconds {
             false
         } else if self.nanoseconds == 0 || other.nanoseconds == 0 {
-            if self.second_ambiguous {
-                false
-            } else {
-                true
-            }
+            !self.second_ambiguous
         } else {
             self.nanoseconds == other.nanoseconds
         }
     }
 
     pub fn likely_equal_to_mtime_of(
         self,
         metadata: &fs::Metadata,
     ) -> io::Result<bool> {
         Ok(self.likely_equal(Self::for_mtime_of(metadata)?))
     }
 }
 
 impl From<SystemTime> for TruncatedTimestamp {
     fn from(system_time: SystemTime) -> Self {
         // On Unix, `SystemTime` is a wrapper for the `timespec` C struct:
         // https://www.gnu.org/software/libc/manual/html_node/Time-Types.html#index-struct-timespec
         // We want to effectively access its fields, but the Rust standard
         // library does not expose them. The best we can do is:
         let seconds;
         let nanoseconds;
         match system_time.duration_since(UNIX_EPOCH) {
             Ok(duration) => {
                 seconds = duration.as_secs() as i64;
                 nanoseconds = duration.subsec_nanos();
             }
             Err(error) => {
                 // `system_time` is before `UNIX_EPOCH`.
                 // We need to undo this algorithm:
                 // https://github.com/rust-lang/rust/blob/6bed1f0bc3cc50c10aab26d5f94b16a00776b8a5/library/std/src/sys/unix/time.rs#L40-L41
                 let negative = error.duration();
                 let negative_secs = negative.as_secs() as i64;
                 let negative_nanos = negative.subsec_nanos();
                 if negative_nanos == 0 {
                     seconds = -negative_secs;
                     nanoseconds = 0;
                 } else {
                     // For example if `system_time` was 4.3 seconds before
                     // the Unix epoch we get a Duration that represents
                     // `(-4, -0.3)` but we want `(-5, +0.7)`:
                     seconds = -1 - negative_secs;
                     nanoseconds = NSEC_PER_SEC - negative_nanos;
                 }
             }
         };
         Self::new_truncate(seconds, nanoseconds, false)
     }
 }
 
 const NSEC_PER_SEC: u32 = 1_000_000_000;
 pub const RANGE_MASK_31BIT: u32 = 0x7FFF_FFFF;
 
 pub const MTIME_UNSET: i32 = -1;
 
 /// 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
 /// merge.
 pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
 /// A special value used for internal representation of special case in
 /// dirstate v1 format.
 pub const SIZE_NON_NORMAL: i32 = -1;
 
 #[derive(Debug, Default, Copy, Clone)]
 pub struct DirstateV2Data {
     pub wc_tracked: bool,
     pub p1_tracked: bool,
     pub p2_info: bool,
     pub mode_size: Option<(u32, u32)>,
     pub mtime: Option<TruncatedTimestamp>,
     pub fallback_exec: Option<bool>,
     pub fallback_symlink: Option<bool>,
 }
 
 #[derive(Debug, Default, Copy, Clone)]
 pub struct ParentFileData {
     pub mode_size: Option<(u32, u32)>,
     pub mtime: Option<TruncatedTimestamp>,
 }
 
 impl DirstateEntry {
     pub fn from_v2_data(v2_data: DirstateV2Data) -> Self {
         let DirstateV2Data {
             wc_tracked,
             p1_tracked,
             p2_info,
             mode_size,
             mtime,
             fallback_exec,
             fallback_symlink,
         } = v2_data;
         if let Some((mode, size)) = mode_size {
             // TODO: return an error for out of range values?
             assert!(mode & !RANGE_MASK_31BIT == 0);
             assert!(size & !RANGE_MASK_31BIT == 0);
         }
         let mut flags = Flags::empty();
         flags.set(Flags::WDIR_TRACKED, wc_tracked);
         flags.set(Flags::P1_TRACKED, p1_tracked);
         flags.set(Flags::P2_INFO, p2_info);
         if let Some(exec) = fallback_exec {
             flags.insert(Flags::HAS_FALLBACK_EXEC);
             if exec {
                 flags.insert(Flags::FALLBACK_EXEC);
             }
         }
         if let Some(exec) = fallback_symlink {
             flags.insert(Flags::HAS_FALLBACK_SYMLINK);
             if exec {
                 flags.insert(Flags::FALLBACK_SYMLINK);
             }
         }
         Self {
             flags,
             mode_size,
             mtime,
         }
     }
 
     pub fn from_v1_data(
         state: EntryState,
         mode: i32,
         size: i32,
         mtime: i32,
     ) -> Self {
         match state {
             EntryState::Normal => {
                 if size == SIZE_FROM_OTHER_PARENT {
                     Self {
                         // might be missing P1_TRACKED
                         flags: Flags::WDIR_TRACKED | Flags::P2_INFO,
                         mode_size: None,
                         mtime: None,
                     }
                 } else if size == SIZE_NON_NORMAL {
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: None,
                         mtime: None,
                     }
                 } else if mtime == MTIME_UNSET {
                     // TODO: return an error for negative values?
                     let mode = u32::try_from(mode).unwrap();
                     let size = u32::try_from(size).unwrap();
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: Some((mode, size)),
                         mtime: None,
                     }
                 } else {
                     // TODO: return an error for negative values?
                     let mode = u32::try_from(mode).unwrap();
                     let size = u32::try_from(size).unwrap();
                     let mtime = u32::try_from(mtime).unwrap();
                     let mtime = TruncatedTimestamp::from_already_truncated(
                         mtime, 0, false,
                     )
                     .unwrap();
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: Some((mode, size)),
                         mtime: Some(mtime),
                     }
                 }
             }
             EntryState::Added => Self {
                 flags: Flags::WDIR_TRACKED,
                 mode_size: None,
                 mtime: None,
             },
             EntryState::Removed => Self {
                 flags: if size == SIZE_NON_NORMAL {
                     Flags::P1_TRACKED | Flags::P2_INFO
                 } else if size == SIZE_FROM_OTHER_PARENT {
                     // We don’t know if P1_TRACKED should be set (file history)
                     Flags::P2_INFO
                 } else {
                     Flags::P1_TRACKED
                 },
                 mode_size: None,
                 mtime: None,
             },
             EntryState::Merged => Self {
                 flags: Flags::WDIR_TRACKED
                     | Flags::P1_TRACKED // might not be true because of rename ?
                     | Flags::P2_INFO, // might not be true because of rename ?
                 mode_size: None,
                 mtime: None,
             },
         }
     }
 
     /// Creates a new entry in "removed" state.
     ///
     /// `size` is expected to be zero, `SIZE_NON_NORMAL`, or
     /// `SIZE_FROM_OTHER_PARENT`
     pub fn new_removed(size: i32) -> Self {
         Self::from_v1_data(EntryState::Removed, 0, size, 0)
     }
 
     pub fn new_tracked() -> Self {
         let data = DirstateV2Data {
             wc_tracked: true,
             ..Default::default()
         };
         Self::from_v2_data(data)
     }
 
     pub fn tracked(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED)
     }
 
     pub fn p1_tracked(&self) -> bool {
         self.flags.contains(Flags::P1_TRACKED)
     }
 
     fn in_either_parent(&self) -> bool {
         self.flags.intersects(Flags::P1_TRACKED | Flags::P2_INFO)
     }
 
     pub fn removed(&self) -> bool {
         self.in_either_parent() && !self.flags.contains(Flags::WDIR_TRACKED)
     }
 
     pub fn p2_info(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED | Flags::P2_INFO)
     }
 
     pub fn added(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED) && !self.in_either_parent()
     }
 
     pub fn modified(&self) -> bool {
         self.flags
             .contains(Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO)
     }
 
     pub fn maybe_clean(&self) -> bool {
         #[allow(clippy::if_same_then_else)]
         #[allow(clippy::needless_bool)]
         if !self.flags.contains(Flags::WDIR_TRACKED) {
             false
         } else if !self.flags.contains(Flags::P1_TRACKED) {
             false
         } else if self.flags.contains(Flags::P2_INFO) {
             false
         } else {
             true
         }
     }
 
     pub fn any_tracked(&self) -> bool {
         self.flags.intersects(
             Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO,
         )
     }
 
     pub(crate) fn v2_data(&self) -> DirstateV2Data {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v2_data of an untracked DirstateEntry")
         }
         let wc_tracked = self.flags.contains(Flags::WDIR_TRACKED);
         let p1_tracked = self.flags.contains(Flags::P1_TRACKED);
         let p2_info = self.flags.contains(Flags::P2_INFO);
         let mode_size = self.mode_size;
         let mtime = self.mtime;
         DirstateV2Data {
             wc_tracked,
             p1_tracked,
             p2_info,
             mode_size,
             mtime,
             fallback_exec: self.get_fallback_exec(),
             fallback_symlink: self.get_fallback_symlink(),
         }
     }
 
     fn v1_state(&self) -> EntryState {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_state of an untracked DirstateEntry")
         }
         if self.removed() {
             EntryState::Removed
         } else if self.modified() {
             EntryState::Merged
         } else if self.added() {
             EntryState::Added
         } else {
             EntryState::Normal
         }
     }
 
     fn v1_mode(&self) -> i32 {
         if let Some((mode, _size)) = self.mode_size {
             i32::try_from(mode).unwrap()
         } else {
             0
         }
     }
 
     fn v1_size(&self) -> i32 {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_size of an untracked DirstateEntry")
         }
         if self.removed()
             && self.flags.contains(Flags::P1_TRACKED | Flags::P2_INFO)
         {
             SIZE_NON_NORMAL
         } else if self.flags.contains(Flags::P2_INFO) {
             SIZE_FROM_OTHER_PARENT
         } else if self.removed() {
             0
         } else if self.added() {
             SIZE_NON_NORMAL
         } else if let Some((_mode, size)) = self.mode_size {
             i32::try_from(size).unwrap()
         } else {
             SIZE_NON_NORMAL
         }
     }
 
     fn v1_mtime(&self) -> i32 {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_mtime of an untracked DirstateEntry")
         }
 
         #[allow(clippy::if_same_then_else)]
         if self.removed() {
             0
         } else if self.flags.contains(Flags::P2_INFO) {
             MTIME_UNSET
         } else if !self.flags.contains(Flags::P1_TRACKED) {
             MTIME_UNSET
         } else if let Some(mtime) = self.mtime {
             if mtime.second_ambiguous {
                 MTIME_UNSET
             } else {
                 i32::try_from(mtime.truncated_seconds()).unwrap()
             }
         } else {
             MTIME_UNSET
         }
     }
 
     // TODO: return `Option<EntryState>`? None when `!self.any_tracked`
     pub fn state(&self) -> EntryState {
         self.v1_state()
     }
 
     // TODO: return Option?
     pub fn mode(&self) -> i32 {
         self.v1_mode()
     }
 
     // TODO: return Option?
     pub fn size(&self) -> i32 {
         self.v1_size()
     }
 
     // TODO: return Option?
     pub fn mtime(&self) -> i32 {
         self.v1_mtime()
     }
 
     pub fn get_fallback_exec(&self) -> Option<bool> {
         if self.flags.contains(Flags::HAS_FALLBACK_EXEC) {
             Some(self.flags.contains(Flags::FALLBACK_EXEC))
         } else {
             None
         }
     }
 
     pub fn set_fallback_exec(&mut self, value: Option<bool>) {
         match value {
             None => {
                 self.flags.remove(Flags::HAS_FALLBACK_EXEC);
                 self.flags.remove(Flags::FALLBACK_EXEC);
             }
             Some(exec) => {
                 self.flags.insert(Flags::HAS_FALLBACK_EXEC);
                 if exec {
                     self.flags.insert(Flags::FALLBACK_EXEC);
                 }
             }
         }
     }
 
     pub fn get_fallback_symlink(&self) -> Option<bool> {
         if self.flags.contains(Flags::HAS_FALLBACK_SYMLINK) {
             Some(self.flags.contains(Flags::FALLBACK_SYMLINK))
         } else {
             None
         }
     }
 
     pub fn set_fallback_symlink(&mut self, value: Option<bool>) {
         match value {
             None => {
                 self.flags.remove(Flags::HAS_FALLBACK_SYMLINK);
                 self.flags.remove(Flags::FALLBACK_SYMLINK);
             }
             Some(symlink) => {
                 self.flags.insert(Flags::HAS_FALLBACK_SYMLINK);
                 if symlink {
                     self.flags.insert(Flags::FALLBACK_SYMLINK);
                 }
             }
         }
     }
 
     pub fn truncated_mtime(&self) -> Option<TruncatedTimestamp> {
         self.mtime
     }
 
     pub fn drop_merge_data(&mut self) {
         if self.flags.contains(Flags::P2_INFO) {
             self.flags.remove(Flags::P2_INFO);
             self.mode_size = None;
             self.mtime = None;
         }
     }
 
     pub fn set_possibly_dirty(&mut self) {
         self.mtime = None
     }
 
     pub fn set_clean(
         &mut self,
         mode: u32,
         size: u32,
         mtime: TruncatedTimestamp,
     ) {
         let size = size & RANGE_MASK_31BIT;
         self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
         self.mode_size = Some((mode, size));
         self.mtime = Some(mtime);
     }
 
     pub fn set_tracked(&mut self) {
         self.flags.insert(Flags::WDIR_TRACKED);
         // `set_tracked` is replacing various `normallookup` call. So we mark
         // the files as needing lookup
         //
         // Consider dropping this in the future in favor of something less
         // broad.
         self.mtime = None;
     }
 
     pub fn set_untracked(&mut self) {
         self.flags.remove(Flags::WDIR_TRACKED);
         self.mode_size = None;
         self.mtime = None;
     }
 
     /// Returns `(state, mode, size, mtime)` for the puprose of serialization
     /// in the dirstate-v1 format.
     ///
     /// This includes marker values such as `mtime == -1`. In the future we may
     /// want to not represent these cases that way in memory, but serialization
     /// will need to keep the same format.
     pub fn v1_data(&self) -> (u8, i32, i32, i32) {
         (
             self.v1_state().into(),
             self.v1_mode(),
             self.v1_size(),
             self.v1_mtime(),
         )
     }
 
     pub(crate) fn is_from_other_parent(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED | Flags::P2_INFO)
     }
 
     // TODO: other platforms
     #[cfg(unix)]
     pub fn mode_changed(
         &self,
         filesystem_metadata: &std::fs::Metadata,
     ) -> bool {
         let dirstate_exec_bit = (self.mode() as u32 & EXEC_BIT_MASK) != 0;
         let fs_exec_bit = has_exec_bit(filesystem_metadata);
         dirstate_exec_bit != fs_exec_bit
     }
 
     /// Returns a `(state, mode, size, mtime)` tuple as for
     /// `DirstateMapMethods::debug_iter`.
     pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
         (self.state().into(), self.mode(), self.size(), self.mtime())
     }
 }
 
 impl EntryState {
     pub fn is_tracked(self) -> bool {
         use EntryState::*;
         match self {
             Normal | Added | Merged => true,
             Removed => false,
         }
     }
 }
 
 impl TryFrom<u8> for EntryState {
     type Error = HgError;
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
             b'n' => Ok(EntryState::Normal),
             b'a' => Ok(EntryState::Added),
             b'r' => Ok(EntryState::Removed),
             b'm' => Ok(EntryState::Merged),
             _ => Err(HgError::CorruptedRepository(format!(
                 "Incorrect dirstate entry state {}",
                 value
             ))),
         }
     }
 }
 
-impl Into<u8> for EntryState {
-    fn into(self) -> u8 {
-        match self {
+impl From<EntryState> for u8 {
+    fn from(val: EntryState) -> Self {
+        match val {
             EntryState::Normal => b'n',
             EntryState::Added => b'a',
             EntryState::Removed => b'r',
             EntryState::Merged => b'm',
         }
     }
 }
 
 const EXEC_BIT_MASK: u32 = 0o100;
 
 pub fn has_exec_bit(metadata: &std::fs::Metadata) -> bool {
     // TODO: How to handle executable permissions on Windows?
     use std::os::unix::fs::MetadataExt;
     (metadata.mode() & EXEC_BIT_MASK) != 0
 }

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

@@ -1,1915 +1,1902 b''
 use bytes_cast::BytesCast;
 use std::borrow::Cow;
 use std::path::PathBuf;
 
 use super::on_disk;
 use super::on_disk::DirstateV2ParseError;
 use super::owning::OwningDirstateMap;
 use super::path_with_basename::WithBasename;
 use crate::dirstate::parsers::pack_entry;
 use crate::dirstate::parsers::packed_entry_size;
 use crate::dirstate::parsers::parse_dirstate_entries;
 use crate::dirstate::CopyMapIter;
 use crate::dirstate::DirstateV2Data;
 use crate::dirstate::ParentFileData;
 use crate::dirstate::StateMapIter;
 use crate::dirstate::TruncatedTimestamp;
 use crate::matchers::Matcher;
 use crate::utils::hg_path::{HgPath, HgPathBuf};
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateMapError;
 use crate::DirstateParents;
 use crate::DirstateStatus;
 use crate::FastHashbrownMap as FastHashMap;
 use crate::PatternFileWarning;
 use crate::StatusError;
 use crate::StatusOptions;
 
 /// Append to an existing data file if the amount of unreachable data (not used
 /// anymore) is less than this fraction of the total amount of existing data.
 const ACCEPTABLE_UNREACHABLE_BYTES_RATIO: f32 = 0.5;
 
 #[derive(Debug, PartialEq, Eq)]
 /// Version of the on-disk format
 pub enum DirstateVersion {
     V1,
     V2,
 }
 
 #[derive(Debug)]
 pub struct DirstateMap<'on_disk> {
     /// Contents of the `.hg/dirstate` file
     pub(super) on_disk: &'on_disk [u8],
 
     pub(super) root: ChildNodes<'on_disk>,
 
     /// Number of nodes anywhere in the tree that have `.entry.is_some()`.
     pub(super) nodes_with_entry_count: u32,
 
     /// Number of nodes anywhere in the tree that have
     /// `.copy_source.is_some()`.
     pub(super) nodes_with_copy_source_count: u32,
 
     /// See on_disk::Header
     pub(super) ignore_patterns_hash: on_disk::IgnorePatternsHash,
 
     /// How many bytes of `on_disk` are not used anymore
     pub(super) unreachable_bytes: u32,
 
     /// Size of the data used to first load this `DirstateMap`. Used in case
     /// we need to write some new metadata, but no new data on disk.
     pub(super) old_data_size: usize,
 
     pub(super) dirstate_version: DirstateVersion,
 }
 
 /// Using a plain `HgPathBuf` of the full path from the repository root as a
 /// map key would also work: all paths in a given map have the same parent
 /// path, so comparing full paths gives the same result as comparing base
 /// names. However `HashMap` would waste time always re-hashing the same
 /// string prefix.
 pub(super) type NodeKey<'on_disk> = WithBasename<Cow<'on_disk, HgPath>>;
 
 /// Similar to `&'tree Cow<'on_disk, HgPath>`, but can also be returned
 /// for on-disk nodes that don’t actually have a `Cow` to borrow.
 #[derive(Debug)]
 pub(super) enum BorrowedPath<'tree, 'on_disk> {
     InMemory(&'tree HgPathBuf),
     OnDisk(&'on_disk HgPath),
 }
 
 #[derive(Debug)]
 pub(super) enum ChildNodes<'on_disk> {
     InMemory(FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
     OnDisk(&'on_disk [on_disk::Node]),
 }
 
 #[derive(Debug)]
 pub(super) enum ChildNodesRef<'tree, 'on_disk> {
     InMemory(&'tree FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>),
     OnDisk(&'on_disk [on_disk::Node]),
 }
 
 #[derive(Debug)]
 pub(super) enum NodeRef<'tree, 'on_disk> {
     InMemory(&'tree NodeKey<'on_disk>, &'tree Node<'on_disk>),
     OnDisk(&'on_disk on_disk::Node),
 }
 
 impl<'tree, 'on_disk> BorrowedPath<'tree, 'on_disk> {
     pub fn detach_from_tree(&self) -> Cow<'on_disk, HgPath> {
         match *self {
             BorrowedPath::InMemory(in_memory) => Cow::Owned(in_memory.clone()),
             BorrowedPath::OnDisk(on_disk) => Cow::Borrowed(on_disk),
         }
     }
 }
 
 impl<'tree, 'on_disk> std::ops::Deref for BorrowedPath<'tree, 'on_disk> {
     type Target = HgPath;
 
     fn deref(&self) -> &HgPath {
         match *self {
             BorrowedPath::InMemory(in_memory) => in_memory,
             BorrowedPath::OnDisk(on_disk) => on_disk,
         }
     }
 }
 
 impl Default for ChildNodes<'_> {
     fn default() -> Self {
         ChildNodes::InMemory(Default::default())
     }
 }
 
 impl<'on_disk> ChildNodes<'on_disk> {
     pub(super) fn as_ref<'tree>(
         &'tree self,
     ) -> ChildNodesRef<'tree, 'on_disk> {
         match self {
             ChildNodes::InMemory(nodes) => ChildNodesRef::InMemory(nodes),
             ChildNodes::OnDisk(nodes) => ChildNodesRef::OnDisk(nodes),
         }
     }
 
     pub(super) fn is_empty(&self) -> bool {
         match self {
             ChildNodes::InMemory(nodes) => nodes.is_empty(),
             ChildNodes::OnDisk(nodes) => nodes.is_empty(),
         }
     }
 
     fn make_mut(
         &mut self,
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
     ) -> Result<
         &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>,
         DirstateV2ParseError,
     > {
         match self {
             ChildNodes::InMemory(nodes) => Ok(nodes),
             ChildNodes::OnDisk(nodes) => {
                 *unreachable_bytes +=
                     std::mem::size_of_val::<[on_disk::Node]>(nodes) as u32;
                 let nodes = nodes
                     .iter()
                     .map(|node| {
                         Ok((
                             node.path(on_disk)?,
                             node.to_in_memory_node(on_disk)?,
                         ))
                     })
                     .collect::<Result<_, _>>()?;
                 *self = ChildNodes::InMemory(nodes);
                 match self {
                     ChildNodes::InMemory(nodes) => Ok(nodes),
                     ChildNodes::OnDisk(_) => unreachable!(),
                 }
             }
         }
     }
 }
 
 impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> {
     pub(super) fn get(
         &self,
         base_name: &HgPath,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
         match self {
             ChildNodesRef::InMemory(nodes) => Ok(nodes
                 .get_key_value(base_name)
                 .map(|(k, v)| NodeRef::InMemory(k, v))),
             ChildNodesRef::OnDisk(nodes) => {
                 let mut parse_result = Ok(());
                 let search_result = nodes.binary_search_by(|node| {
                     match node.base_name(on_disk) {
                         Ok(node_base_name) => node_base_name.cmp(base_name),
                         Err(e) => {
                             parse_result = Err(e);
                             // Dummy comparison result, `search_result` won’t
                             // be used since `parse_result` is an error
                             std::cmp::Ordering::Equal
                         }
                     }
                 });
                 parse_result.map(|()| {
                     search_result.ok().map(|i| NodeRef::OnDisk(&nodes[i]))
                 })
             }
         }
     }
 
     /// Iterate in undefined order
     pub(super) fn iter(
         &self,
     ) -> impl Iterator<Item = NodeRef<'tree, 'on_disk>> {
         match self {
             ChildNodesRef::InMemory(nodes) => itertools::Either::Left(
                 nodes.iter().map(|(k, v)| NodeRef::InMemory(k, v)),
             ),
             ChildNodesRef::OnDisk(nodes) => {
                 itertools::Either::Right(nodes.iter().map(NodeRef::OnDisk))
             }
         }
     }
 
     /// Iterate in parallel in undefined order
     pub(super) fn par_iter(
         &self,
     ) -> impl rayon::iter::ParallelIterator<Item = NodeRef<'tree, 'on_disk>>
     {
         use rayon::prelude::*;
         match self {
             ChildNodesRef::InMemory(nodes) => rayon::iter::Either::Left(
                 nodes.par_iter().map(|(k, v)| NodeRef::InMemory(k, v)),
             ),
             ChildNodesRef::OnDisk(nodes) => rayon::iter::Either::Right(
                 nodes.par_iter().map(NodeRef::OnDisk),
             ),
         }
     }
 
     pub(super) fn sorted(&self) -> Vec<NodeRef<'tree, 'on_disk>> {
         match self {
             ChildNodesRef::InMemory(nodes) => {
                 let mut vec: Vec<_> = nodes
                     .iter()
                     .map(|(k, v)| NodeRef::InMemory(k, v))
                     .collect();
                 fn sort_key<'a>(node: &'a NodeRef) -> &'a HgPath {
                     match node {
                         NodeRef::InMemory(path, _node) => path.base_name(),
                         NodeRef::OnDisk(_) => unreachable!(),
                     }
                 }
                 // `sort_unstable_by_key` doesn’t allow keys borrowing from the
                 // value: https://github.com/rust-lang/rust/issues/34162
                 vec.sort_unstable_by(|a, b| sort_key(a).cmp(sort_key(b)));
                 vec
             }
             ChildNodesRef::OnDisk(nodes) => {
                 // Nodes on disk are already sorted
                 nodes.iter().map(NodeRef::OnDisk).collect()
             }
         }
     }
 }
 
 impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> {
     pub(super) fn full_path(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'tree HgPath, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => Ok(path.full_path()),
             NodeRef::OnDisk(node) => node.full_path(on_disk),
         }
     }
 
     /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,
     /// HgPath>` detached from `'tree`
     pub(super) fn full_path_borrowed(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<BorrowedPath<'tree, 'on_disk>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => match path.full_path() {
                 Cow::Borrowed(on_disk) => Ok(BorrowedPath::OnDisk(on_disk)),
                 Cow::Owned(in_memory) => Ok(BorrowedPath::InMemory(in_memory)),
             },
             NodeRef::OnDisk(node) => {
                 Ok(BorrowedPath::OnDisk(node.full_path(on_disk)?))
             }
         }
     }
 
     pub(super) fn base_name(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'tree HgPath, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(path, _node) => Ok(path.base_name()),
             NodeRef::OnDisk(node) => node.base_name(on_disk),
         }
     }
 
     pub(super) fn children(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()),
             NodeRef::OnDisk(node) => {
                 Ok(ChildNodesRef::OnDisk(node.children(on_disk)?))
             }
         }
     }
 
     pub(super) fn has_copy_source(&self) -> bool {
         match self {
             NodeRef::InMemory(_path, node) => node.copy_source.is_some(),
             NodeRef::OnDisk(node) => node.has_copy_source(),
         }
     }
 
     pub(super) fn copy_source(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> {
         match self {
-            NodeRef::InMemory(_path, node) => {
-                Ok(node.copy_source.as_ref().map(|s| &**s))
-            }
+            NodeRef::InMemory(_path, node) => Ok(node.copy_source.as_deref()),
             NodeRef::OnDisk(node) => node.copy_source(on_disk),
         }
     }
     /// Returns a `BorrowedPath`, which can be turned into a `Cow<'on_disk,
     /// HgPath>` detached from `'tree`
     pub(super) fn copy_source_borrowed(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<BorrowedPath<'tree, 'on_disk>>, DirstateV2ParseError>
     {
         Ok(match self {
             NodeRef::InMemory(_path, node) => {
                 node.copy_source.as_ref().map(|source| match source {
                     Cow::Borrowed(on_disk) => BorrowedPath::OnDisk(on_disk),
                     Cow::Owned(in_memory) => BorrowedPath::InMemory(in_memory),
                 })
             }
-            NodeRef::OnDisk(node) => node
-                .copy_source(on_disk)?
-                .map(|source| BorrowedPath::OnDisk(source)),
+            NodeRef::OnDisk(node) => {
+                node.copy_source(on_disk)?.map(BorrowedPath::OnDisk)
+            }
         })
     }
 
     pub(super) fn entry(
         &self,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => {
                 Ok(node.data.as_entry().copied())
             }
             NodeRef::OnDisk(node) => node.entry(),
         }
     }
 
     pub(super) fn cached_directory_mtime(
         &self,
     ) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> {
         match self {
             NodeRef::InMemory(_path, node) => Ok(match node.data {
                 NodeData::CachedDirectory { mtime } => Some(mtime),
                 _ => None,
             }),
             NodeRef::OnDisk(node) => node.cached_directory_mtime(),
         }
     }
 
     pub(super) fn descendants_with_entry_count(&self) -> u32 {
         match self {
             NodeRef::InMemory(_path, node) => {
                 node.descendants_with_entry_count
             }
             NodeRef::OnDisk(node) => node.descendants_with_entry_count.get(),
         }
     }
 
     pub(super) fn tracked_descendants_count(&self) -> u32 {
         match self {
             NodeRef::InMemory(_path, node) => node.tracked_descendants_count,
             NodeRef::OnDisk(node) => node.tracked_descendants_count.get(),
         }
     }
 }
 
 /// Represents a file or a directory
 #[derive(Default, Debug)]
 pub(super) struct Node<'on_disk> {
     pub(super) data: NodeData,
 
     pub(super) copy_source: Option<Cow<'on_disk, HgPath>>,
 
     pub(super) children: ChildNodes<'on_disk>,
 
     /// How many (non-inclusive) descendants of this node have an entry.
     pub(super) descendants_with_entry_count: u32,
 
     /// How many (non-inclusive) descendants of this node have an entry whose
     /// state is "tracked".
     pub(super) tracked_descendants_count: u32,
 }
 
 #[derive(Debug)]
 pub(super) enum NodeData {
     Entry(DirstateEntry),
     CachedDirectory { mtime: TruncatedTimestamp },
     None,
 }
 
 impl Default for NodeData {
     fn default() -> Self {
         NodeData::None
     }
 }
 
 impl NodeData {
     fn has_entry(&self) -> bool {
-        match self {
-            NodeData::Entry(_) => true,
-            _ => false,
-        }
+        matches!(self, NodeData::Entry(_))
     }
 
     fn as_entry(&self) -> Option<&DirstateEntry> {
         match self {
             NodeData::Entry(entry) => Some(entry),
             _ => None,
         }
     }
 
     fn as_entry_mut(&mut self) -> Option<&mut DirstateEntry> {
         match self {
             NodeData::Entry(entry) => Some(entry),
             _ => None,
         }
     }
 }
 
 impl<'on_disk> DirstateMap<'on_disk> {
     pub(super) fn empty(on_disk: &'on_disk [u8]) -> Self {
         Self {
             on_disk,
             root: ChildNodes::default(),
             nodes_with_entry_count: 0,
             nodes_with_copy_source_count: 0,
             ignore_patterns_hash: [0; on_disk::IGNORE_PATTERNS_HASH_LEN],
             unreachable_bytes: 0,
             old_data_size: 0,
             dirstate_version: DirstateVersion::V1,
         }
     }
 
     #[logging_timer::time("trace")]
     pub fn new_v2(
         on_disk: &'on_disk [u8],
         data_size: usize,
         metadata: &[u8],
     ) -> Result<Self, DirstateError> {
         if let Some(data) = on_disk.get(..data_size) {
             Ok(on_disk::read(data, metadata)?)
         } else {
             Err(DirstateV2ParseError::new("not enough bytes on disk").into())
         }
     }
 
     #[logging_timer::time("trace")]
     pub fn new_v1(
         on_disk: &'on_disk [u8],
     ) -> Result<(Self, Option<DirstateParents>), DirstateError> {
         let mut map = Self::empty(on_disk);
         if map.on_disk.is_empty() {
             return Ok((map, None));
         }
 
         let parents = parse_dirstate_entries(
             map.on_disk,
             |path, entry, copy_source| {
                 let tracked = entry.tracked();
                 let node = Self::get_or_insert_node_inner(
                     map.on_disk,
                     &mut map.unreachable_bytes,
                     &mut map.root,
                     path,
                     WithBasename::to_cow_borrowed,
                     |ancestor| {
                         if tracked {
                             ancestor.tracked_descendants_count += 1
                         }
                         ancestor.descendants_with_entry_count += 1
                     },
                 )?;
                 assert!(
                     !node.data.has_entry(),
                     "duplicate dirstate entry in read"
                 );
                 assert!(
                     node.copy_source.is_none(),
                     "duplicate dirstate entry in read"
                 );
                 node.data = NodeData::Entry(*entry);
                 node.copy_source = copy_source.map(Cow::Borrowed);
                 map.nodes_with_entry_count += 1;
                 if copy_source.is_some() {
                     map.nodes_with_copy_source_count += 1
                 }
                 Ok(())
             },
         )?;
-        let parents = Some(parents.clone());
+        let parents = Some(*parents);
 
         Ok((map, parents))
     }
 
     /// Assuming dirstate-v2 format, returns whether the next write should
     /// append to the existing data file that contains `self.on_disk` (true),
     /// or create a new data file from scratch (false).
     pub(super) fn write_should_append(&self) -> bool {
         let ratio = self.unreachable_bytes as f32 / self.on_disk.len() as f32;
         ratio < ACCEPTABLE_UNREACHABLE_BYTES_RATIO
     }
 
     fn get_node<'tree>(
         &'tree self,
         path: &HgPath,
     ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> {
         let mut children = self.root.as_ref();
         let mut components = path.components();
         let mut component =
             components.next().expect("expected at least one components");
         loop {
             if let Some(child) = children.get(component, self.on_disk)? {
                 if let Some(next_component) = components.next() {
                     component = next_component;
                     children = child.children(self.on_disk)?;
                 } else {
                     return Ok(Some(child));
                 }
             } else {
                 return Ok(None);
             }
         }
     }
 
     /// Returns a mutable reference to the node at `path` if it exists
     ///
     /// `each_ancestor` is a callback that is called for each ancestor node
     /// when descending the tree. It is used to keep the different counters
     /// of the `DirstateMap` up-to-date.
     fn get_node_mut<'tree>(
         &'tree mut self,
         path: &HgPath,
         each_ancestor: impl FnMut(&mut Node),
     ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {
         Self::get_node_mut_inner(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             path,
             each_ancestor,
         )
     }
 
     /// Lower-level version of `get_node_mut`.
     ///
     /// This takes `root` instead of `&mut self` so that callers can mutate
     /// other fields while the returned borrow is still valid.
     ///
     /// `each_ancestor` is a callback that is called for each ancestor node
     /// when descending the tree. It is used to keep the different counters
     /// of the `DirstateMap` up-to-date.
     fn get_node_mut_inner<'tree>(
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
         root: &'tree mut ChildNodes<'on_disk>,
         path: &HgPath,
         mut each_ancestor: impl FnMut(&mut Node),
     ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> {
         let mut children = root;
         let mut components = path.components();
         let mut component =
             components.next().expect("expected at least one components");
         loop {
             if let Some(child) = children
                 .make_mut(on_disk, unreachable_bytes)?
                 .get_mut(component)
             {
                 if let Some(next_component) = components.next() {
                     each_ancestor(child);
                     component = next_component;
                     children = &mut child.children;
                 } else {
                     return Ok(Some(child));
                 }
             } else {
                 return Ok(None);
             }
         }
     }
 
     /// Get a mutable reference to the node at `path`, creating it if it does
     /// not exist.
     ///
     /// `each_ancestor` is a callback that is called for each ancestor node
     /// when descending the tree. It is used to keep the different counters
     /// of the `DirstateMap` up-to-date.
     fn get_or_insert_node<'tree, 'path>(
         &'tree mut self,
         path: &'path HgPath,
         each_ancestor: impl FnMut(&mut Node),
     ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> {
         Self::get_or_insert_node_inner(
             self.on_disk,
             &mut self.unreachable_bytes,
             &mut self.root,
             path,
             WithBasename::to_cow_owned,
             each_ancestor,
         )
     }
 
     /// Lower-level version of `get_or_insert_node_inner`, which is used when
     /// parsing disk data to remove allocations for new nodes.
     fn get_or_insert_node_inner<'tree, 'path>(
         on_disk: &'on_disk [u8],
         unreachable_bytes: &mut u32,
         root: &'tree mut ChildNodes<'on_disk>,
         path: &'path HgPath,
         to_cow: impl Fn(
             WithBasename<&'path HgPath>,
         ) -> WithBasename<Cow<'on_disk, HgPath>>,
         mut each_ancestor: impl FnMut(&mut Node),
     ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> {
         let mut child_nodes = root;
         let mut inclusive_ancestor_paths =
             WithBasename::inclusive_ancestors_of(path);
         let mut ancestor_path = inclusive_ancestor_paths
             .next()
             .expect("expected at least one inclusive ancestor");
         loop {
             let (_, child_node) = child_nodes
                 .make_mut(on_disk, unreachable_bytes)?
                 .raw_entry_mut()
                 .from_key(ancestor_path.base_name())
                 .or_insert_with(|| (to_cow(ancestor_path), Node::default()));
             if let Some(next) = inclusive_ancestor_paths.next() {
                 each_ancestor(child_node);
                 ancestor_path = next;
                 child_nodes = &mut child_node.children;
             } else {
                 return Ok(child_node);
             }
         }
     }
 
     #[allow(clippy::too_many_arguments)]
     fn reset_state(
         &mut self,
         filename: &HgPath,
         old_entry_opt: Option<DirstateEntry>,
         wc_tracked: bool,
         p1_tracked: bool,
         p2_info: bool,
         has_meaningful_mtime: bool,
         parent_file_data_opt: Option<ParentFileData>,
     ) -> Result<(), DirstateError> {
         let (had_entry, was_tracked) = match old_entry_opt {
             Some(old_entry) => (true, old_entry.tracked()),
             None => (false, false),
         };
         let node = self.get_or_insert_node(filename, |ancestor| {
             if !had_entry {
                 ancestor.descendants_with_entry_count += 1;
             }
             if was_tracked {
                 if !wc_tracked {
                     ancestor.tracked_descendants_count = ancestor
                         .tracked_descendants_count
                         .checked_sub(1)
                         .expect("tracked count to be >= 0");
                 }
-            } else {
-                if wc_tracked {
-                    ancestor.tracked_descendants_count += 1;
-                }
+            } else if wc_tracked {
+                ancestor.tracked_descendants_count += 1;
             }
         })?;
 
         let v2_data = if let Some(parent_file_data) = parent_file_data_opt {
             DirstateV2Data {
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 mode_size: parent_file_data.mode_size,
                 mtime: if has_meaningful_mtime {
                     parent_file_data.mtime
                 } else {
                     None
                 },
                 ..Default::default()
             }
         } else {
             DirstateV2Data {
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 ..Default::default()
             }
         };
         node.data = NodeData::Entry(DirstateEntry::from_v2_data(v2_data));
         if !had_entry {
             self.nodes_with_entry_count += 1;
         }
         Ok(())
     }
 
     fn set_tracked(
         &mut self,
         filename: &HgPath,
         old_entry_opt: Option<DirstateEntry>,
     ) -> Result<bool, DirstateV2ParseError> {
         let was_tracked = old_entry_opt.map_or(false, |e| e.tracked());
         let had_entry = old_entry_opt.is_some();
         let tracked_count_increment = if was_tracked { 0 } else { 1 };
         let mut new = false;
 
         let node = self.get_or_insert_node(filename, |ancestor| {
             if !had_entry {
                 ancestor.descendants_with_entry_count += 1;
             }
 
             ancestor.tracked_descendants_count += tracked_count_increment;
         })?;
         if let Some(old_entry) = old_entry_opt {
-            let mut e = old_entry.clone();
+            let mut e = old_entry;
             if e.tracked() {
                 // XXX
                 // This is probably overkill for more case, but we need this to
                 // fully replace the `normallookup` call with `set_tracked`
                 // one. Consider smoothing this in the future.
                 e.set_possibly_dirty();
             } else {
                 new = true;
                 e.set_tracked();
             }
             node.data = NodeData::Entry(e)
         } else {
             node.data = NodeData::Entry(DirstateEntry::new_tracked());
             self.nodes_with_entry_count += 1;
             new = true;
         };
         Ok(new)
     }
 
     /// Set a node as untracked in the dirstate.
     ///
     /// It is the responsibility of the caller to remove the copy source and/or
     /// the entry itself if appropriate.
     ///
     /// # Panics
     ///
     /// Panics if the node does not exist.
     fn set_untracked(
         &mut self,
         filename: &HgPath,
         old_entry: DirstateEntry,
     ) -> Result<(), DirstateV2ParseError> {
         let node = self
             .get_node_mut(filename, |ancestor| {
                 ancestor.tracked_descendants_count = ancestor
                     .tracked_descendants_count
                     .checked_sub(1)
                     .expect("tracked_descendants_count should be >= 0");
             })?
             .expect("node should exist");
-        let mut new_entry = old_entry.clone();
+        let mut new_entry = old_entry;
         new_entry.set_untracked();
         node.data = NodeData::Entry(new_entry);
         Ok(())
     }
 
     /// Set a node as clean in the dirstate.
     ///
     /// It is the responsibility of the caller to remove the copy source.
     ///
     /// # Panics
     ///
     /// Panics if the node does not exist.
     fn set_clean(
         &mut self,
         filename: &HgPath,
         old_entry: DirstateEntry,
         mode: u32,
         size: u32,
         mtime: TruncatedTimestamp,
     ) -> Result<(), DirstateError> {
         let node = self
             .get_node_mut(filename, |ancestor| {
                 if !old_entry.tracked() {
                     ancestor.tracked_descendants_count += 1;
                 }
             })?
             .expect("node should exist");
-        let mut new_entry = old_entry.clone();
+        let mut new_entry = old_entry;
         new_entry.set_clean(mode, size, mtime);
         node.data = NodeData::Entry(new_entry);
         Ok(())
     }
 
     /// Set a node as possibly dirty in the dirstate.
     ///
     /// # Panics
     ///
     /// Panics if the node does not exist.
     fn set_possibly_dirty(
         &mut self,
         filename: &HgPath,
     ) -> Result<(), DirstateError> {
         let node = self
             .get_node_mut(filename, |_ancestor| {})?
             .expect("node should exist");
         let entry = node.data.as_entry_mut().expect("entry should exist");
         entry.set_possibly_dirty();
         node.data = NodeData::Entry(*entry);
         Ok(())
     }
 
     /// Clears the cached mtime for the (potential) folder at `path`.
     pub(super) fn clear_cached_mtime(
         &mut self,
         path: &HgPath,
     ) -> Result<(), DirstateV2ParseError> {
         let node = match self.get_node_mut(path, |_ancestor| {})? {
             Some(node) => node,
             None => return Ok(()),
         };
         if let NodeData::CachedDirectory { .. } = &node.data {
             node.data = NodeData::None
         }
         Ok(())
     }
 
     /// Sets the cached mtime for the (potential) folder at `path`.
     pub(super) fn set_cached_mtime(
         &mut self,
         path: &HgPath,
         mtime: TruncatedTimestamp,
     ) -> Result<(), DirstateV2ParseError> {
         let node = match self.get_node_mut(path, |_ancestor| {})? {
             Some(node) => node,
             None => return Ok(()),
         };
         match &node.data {
             NodeData::Entry(_) => {} // Don’t overwrite an entry
             NodeData::CachedDirectory { .. } | NodeData::None => {
                 node.data = NodeData::CachedDirectory { mtime }
             }
         }
         Ok(())
     }
 
     fn iter_nodes<'tree>(
         &'tree self,
     ) -> impl Iterator<
         Item = Result<NodeRef<'tree, 'on_disk>, DirstateV2ParseError>,
     > + 'tree {
         // Depth first tree traversal.
         //
         // If we could afford internal iteration and recursion,
         // this would look like:
         //
         // ```
         // fn traverse_children(
         //     children: &ChildNodes,
         //     each: &mut impl FnMut(&Node),
         // ) {
         //     for child in children.values() {
         //         traverse_children(&child.children, each);
         //         each(child);
         //     }
         // }
         // ```
         //
         // However we want an external iterator and therefore can’t use the
         // call stack. Use an explicit stack instead:
         let mut stack = Vec::new();
         let mut iter = self.root.as_ref().iter();
         std::iter::from_fn(move || {
             while let Some(child_node) = iter.next() {
                 let children = match child_node.children(self.on_disk) {
                     Ok(children) => children,
                     Err(error) => return Some(Err(error)),
                 };
                 // Pseudo-recursion
                 let new_iter = children.iter();
                 let old_iter = std::mem::replace(&mut iter, new_iter);
                 stack.push((child_node, old_iter));
             }
             // Found the end of a `children.iter()` iterator.
             if let Some((child_node, next_iter)) = stack.pop() {
                 // "Return" from pseudo-recursion by restoring state from the
                 // explicit stack
                 iter = next_iter;
 
                 Some(Ok(child_node))
             } else {
                 // Reached the bottom of the stack, we’re done
                 None
             }
         })
     }
 
     fn count_dropped_path(unreachable_bytes: &mut u32, path: Cow<HgPath>) {
         if let Cow::Borrowed(path) = path {
             *unreachable_bytes += path.len() as u32
         }
     }
 }
 
 /// 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>(
     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)),
     })
 }
 
 type DebugDirstateTuple<'a> = (&'a HgPath, (u8, i32, i32, i32));
 
 impl OwningDirstateMap {
     pub fn clear(&mut self) {
         self.with_dmap_mut(|map| {
             map.root = Default::default();
             map.nodes_with_entry_count = 0;
             map.nodes_with_copy_source_count = 0;
         });
     }
 
     pub fn set_tracked(
         &mut self,
         filename: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         let old_entry_opt = self.get(filename)?;
         self.with_dmap_mut(|map| map.set_tracked(filename, old_entry_opt))
     }
 
     pub fn set_untracked(
         &mut self,
         filename: &HgPath,
     ) -> Result<bool, DirstateError> {
         let old_entry_opt = self.get(filename)?;
         match old_entry_opt {
             None => Ok(false),
             Some(old_entry) => {
                 if !old_entry.tracked() {
                     // `DirstateMap::set_untracked` is not a noop if
                     // already not tracked as it will decrement the
                     // tracked counters while going down.
                     return Ok(true);
                 }
                 if old_entry.added() {
                     // Untracking an "added" entry will just result in a
                     // worthless entry (and other parts of the code will
                     // complain about it), just drop it entirely.
                     self.drop_entry_and_copy_source(filename)?;
                     return Ok(true);
                 }
                 if !old_entry.p2_info() {
                     self.copy_map_remove(filename)?;
                 }
 
                 self.with_dmap_mut(|map| {
                     map.set_untracked(filename, old_entry)?;
                     Ok(true)
                 })
             }
         }
     }
 
     pub fn set_clean(
         &mut self,
         filename: &HgPath,
         mode: u32,
         size: u32,
         mtime: TruncatedTimestamp,
     ) -> Result<(), DirstateError> {
         let old_entry = match self.get(filename)? {
             None => {
                 return Err(
                     DirstateMapError::PathNotFound(filename.into()).into()
                 )
             }
             Some(e) => e,
         };
         self.copy_map_remove(filename)?;
         self.with_dmap_mut(|map| {
             map.set_clean(filename, old_entry, mode, size, mtime)
         })
     }
 
     pub fn set_possibly_dirty(
         &mut self,
         filename: &HgPath,
     ) -> Result<(), DirstateError> {
         if self.get(filename)?.is_none() {
             return Err(DirstateMapError::PathNotFound(filename.into()).into());
         }
         self.with_dmap_mut(|map| map.set_possibly_dirty(filename))
     }
 
     pub fn reset_state(
         &mut self,
         filename: &HgPath,
         wc_tracked: bool,
         p1_tracked: bool,
         p2_info: bool,
         has_meaningful_mtime: bool,
         parent_file_data_opt: Option<ParentFileData>,
     ) -> Result<(), DirstateError> {
         if !(p1_tracked || p2_info || wc_tracked) {
             self.drop_entry_and_copy_source(filename)?;
             return Ok(());
         }
         self.copy_map_remove(filename)?;
         let old_entry_opt = self.get(filename)?;
         self.with_dmap_mut(|map| {
             map.reset_state(
                 filename,
                 old_entry_opt,
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 has_meaningful_mtime,
                 parent_file_data_opt,
             )
         })
     }
 
     pub fn drop_entry_and_copy_source(
         &mut self,
         filename: &HgPath,
     ) -> Result<(), DirstateError> {
         let was_tracked = self.get(filename)?.map_or(false, |e| e.tracked());
         struct Dropped {
             was_tracked: bool,
             had_entry: bool,
             had_copy_source: bool,
         }
 
         /// If this returns `Ok(Some((dropped, removed)))`, then
         ///
         /// * `dropped` is about the leaf node that was at `filename`
         /// * `removed` is whether this particular level of recursion just
         ///   removed a node in `nodes`.
         fn recur<'on_disk>(
             on_disk: &'on_disk [u8],
             unreachable_bytes: &mut u32,
             nodes: &mut ChildNodes<'on_disk>,
             path: &HgPath,
         ) -> Result<Option<(Dropped, bool)>, DirstateV2ParseError> {
             let (first_path_component, rest_of_path) =
                 path.split_first_component();
             let nodes = nodes.make_mut(on_disk, unreachable_bytes)?;
             let node = if let Some(node) = nodes.get_mut(first_path_component)
             {
                 node
             } else {
                 return Ok(None);
             };
             let dropped;
             if let Some(rest) = rest_of_path {
                 if let Some((d, removed)) = recur(
                     on_disk,
                     unreachable_bytes,
                     &mut node.children,
                     rest,
                 )? {
                     dropped = d;
                     if dropped.had_entry {
                         node.descendants_with_entry_count = node
                             .descendants_with_entry_count
                             .checked_sub(1)
                             .expect(
                                 "descendants_with_entry_count should be >= 0",
                             );
                     }
                     if dropped.was_tracked {
                         node.tracked_descendants_count = node
                             .tracked_descendants_count
                             .checked_sub(1)
                             .expect(
                                 "tracked_descendants_count should be >= 0",
                             );
                     }
 
                     // Directory caches must be invalidated when removing a
                     // child node
                     if removed {
                         if let NodeData::CachedDirectory { .. } = &node.data {
                             node.data = NodeData::None
                         }
                     }
                 } else {
                     return Ok(None);
                 }
             } else {
                 let entry = node.data.as_entry();
                 let was_tracked = entry.map_or(false, |entry| entry.tracked());
                 let had_entry = entry.is_some();
                 if had_entry {
                     node.data = NodeData::None
                 }
                 let mut had_copy_source = false;
                 if let Some(source) = &node.copy_source {
                     DirstateMap::count_dropped_path(
                         unreachable_bytes,
                         Cow::Borrowed(source),
                     );
                     had_copy_source = true;
                     node.copy_source = None
                 }
                 dropped = Dropped {
                     was_tracked,
                     had_entry,
                     had_copy_source,
                 };
             }
             // After recursion, for both leaf (rest_of_path is None) nodes and
             // parent nodes, remove a node if it just became empty.
             let remove = !node.data.has_entry()
                 && node.copy_source.is_none()
                 && node.children.is_empty();
             if remove {
                 let (key, _) =
                     nodes.remove_entry(first_path_component).unwrap();
                 DirstateMap::count_dropped_path(
                     unreachable_bytes,
                     Cow::Borrowed(key.full_path()),
                 )
             }
             Ok(Some((dropped, remove)))
         }
 
         self.with_dmap_mut(|map| {
             if let Some((dropped, _removed)) = recur(
                 map.on_disk,
                 &mut map.unreachable_bytes,
                 &mut map.root,
                 filename,
             )? {
                 if dropped.had_entry {
                     map.nodes_with_entry_count = map
                         .nodes_with_entry_count
                         .checked_sub(1)
                         .expect("nodes_with_entry_count should be >= 0");
                 }
                 if dropped.had_copy_source {
                     map.nodes_with_copy_source_count = map
                         .nodes_with_copy_source_count
                         .checked_sub(1)
                         .expect("nodes_with_copy_source_count should be >= 0");
                 }
             } else {
                 debug_assert!(!was_tracked);
             }
             Ok(())
         })
     }
 
     pub fn has_tracked_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.with_dmap_mut(|map| {
             if let Some(node) = map.get_node(directory)? {
                 // A node without a `DirstateEntry` was created to hold child
                 // nodes, and is therefore a directory.
                 let is_dir = node.entry()?.is_none();
                 Ok(is_dir && node.tracked_descendants_count() > 0)
             } else {
                 Ok(false)
             }
         })
     }
 
     pub fn has_dir(
         &mut self,
         directory: &HgPath,
     ) -> Result<bool, DirstateError> {
         self.with_dmap_mut(|map| {
             if let Some(node) = map.get_node(directory)? {
                 // A node without a `DirstateEntry` was created to hold child
                 // nodes, and is therefore a directory.
                 let is_dir = node.entry()?.is_none();
                 Ok(is_dir && node.descendants_with_entry_count() > 0)
             } else {
                 Ok(false)
             }
         })
     }
 
     #[logging_timer::time("trace")]
     pub fn pack_v1(
         &self,
         parents: DirstateParents,
     ) -> Result<Vec<u8>, DirstateError> {
         let map = self.get_map();
         // Optizimation (to be measured?): pre-compute size to avoid `Vec`
         // reallocations
         let mut size = parents.as_bytes().len();
         for node in map.iter_nodes() {
             let node = node?;
             if node.entry()?.is_some() {
                 size += packed_entry_size(
                     node.full_path(map.on_disk)?,
                     node.copy_source(map.on_disk)?,
                 );
             }
         }
 
         let mut packed = Vec::with_capacity(size);
         packed.extend(parents.as_bytes());
 
         for node in map.iter_nodes() {
             let node = node?;
             if let Some(entry) = node.entry()? {
                 pack_entry(
                     node.full_path(map.on_disk)?,
                     &entry,
                     node.copy_source(map.on_disk)?,
                     &mut packed,
                 );
             }
         }
         Ok(packed)
     }
 
     /// Returns new data and metadata together with whether that data should be
     /// appended to the existing data file whose content is at
     /// `map.on_disk` (true), instead of written to a new data file
     /// (false), and the previous size of data on disk.
     #[logging_timer::time("trace")]
     pub fn pack_v2(
         &self,
         can_append: bool,
     ) -> Result<(Vec<u8>, on_disk::TreeMetadata, bool, usize), DirstateError>
     {
         let map = self.get_map();
         on_disk::write(map, can_append)
     }
 
     /// `callback` allows the caller to process and do something with the
     /// results of the status. This is needed to do so efficiently (i.e.
     /// without cloning the `DirstateStatus` object with its paths) because
     /// we need to borrow from `Self`.
     pub fn with_status<R>(
         &mut self,
         matcher: &(dyn Matcher + Sync),
         root_dir: PathBuf,
         ignore_files: Vec<PathBuf>,
         options: StatusOptions,
         callback: impl for<'r> FnOnce(
             Result<(DirstateStatus<'r>, Vec<PatternFileWarning>), StatusError>,
         ) -> R,
     ) -> R {
         self.with_dmap_mut(|map| {
             callback(super::status::status(
                 map,
                 matcher,
                 root_dir,
                 ignore_files,
                 options,
             ))
         })
     }
 
     pub fn copy_map_len(&self) -> usize {
         let map = self.get_map();
         map.nodes_with_copy_source_count as usize
     }
 
     pub fn copy_map_iter(&self) -> CopyMapIter<'_> {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             Ok(if let Some(source) = node.copy_source(map.on_disk)? {
                 Some((node.full_path(map.on_disk)?, source))
             } else {
                 None
             })
         }))
     }
 
     pub fn copy_map_contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         let map = self.get_map();
         Ok(if let Some(node) = map.get_node(key)? {
             node.has_copy_source()
         } else {
             false
         })
     }
 
     pub fn copy_map_get(
         &self,
         key: &HgPath,
     ) -> Result<Option<&HgPath>, DirstateV2ParseError> {
         let map = self.get_map();
         if let Some(node) = map.get_node(key)? {
             if let Some(source) = node.copy_source(map.on_disk)? {
                 return Ok(Some(source));
             }
         }
         Ok(None)
     }
 
     pub fn copy_map_remove(
         &mut self,
         key: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         self.with_dmap_mut(|map| {
             let count = &mut map.nodes_with_copy_source_count;
             let unreachable_bytes = &mut map.unreachable_bytes;
             Ok(DirstateMap::get_node_mut_inner(
                 map.on_disk,
                 unreachable_bytes,
                 &mut map.root,
                 key,
                 |_ancestor| {},
             )?
             .and_then(|node| {
                 if let Some(source) = &node.copy_source {
                     *count = count
                         .checked_sub(1)
                         .expect("nodes_with_copy_source_count should be >= 0");
                     DirstateMap::count_dropped_path(
                         unreachable_bytes,
                         Cow::Borrowed(source),
                     );
                 }
                 node.copy_source.take().map(Cow::into_owned)
             }))
         })
     }
 
     pub fn copy_map_insert(
         &mut self,
         key: &HgPath,
         value: &HgPath,
     ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> {
         self.with_dmap_mut(|map| {
-            let node = map.get_or_insert_node(&key, |_ancestor| {})?;
+            let node = map.get_or_insert_node(key, |_ancestor| {})?;
             let had_copy_source = node.copy_source.is_none();
             let old = node
                 .copy_source
                 .replace(value.to_owned().into())
                 .map(Cow::into_owned);
             if had_copy_source {
                 map.nodes_with_copy_source_count += 1
             }
             Ok(old)
         })
     }
 
     pub fn len(&self) -> usize {
         let map = self.get_map();
         map.nodes_with_entry_count as usize
     }
 
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     pub fn contains_key(
         &self,
         key: &HgPath,
     ) -> Result<bool, DirstateV2ParseError> {
         Ok(self.get(key)?.is_some())
     }
 
     pub fn get(
         &self,
         key: &HgPath,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         let map = self.get_map();
         Ok(if let Some(node) = map.get_node(key)? {
             node.entry()?
         } else {
             None
         })
     }
 
     pub fn iter(&self) -> StateMapIter<'_> {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             Ok(if let Some(entry) = node.entry()? {
                 Some((node.full_path(map.on_disk)?, entry))
             } else {
                 None
             })
         }))
     }
 
     pub fn iter_tracked_dirs(
         &mut self,
     ) -> Result<
         Box<
             dyn Iterator<Item = Result<&HgPath, DirstateV2ParseError>>
                 + Send
                 + '_,
         >,
         DirstateError,
     > {
         let map = self.get_map();
         let on_disk = map.on_disk;
         Ok(Box::new(filter_map_results(
             map.iter_nodes(),
             move |node| {
                 Ok(if node.tracked_descendants_count() > 0 {
                     Some(node.full_path(on_disk)?)
                 } else {
                     None
                 })
             },
         )))
     }
 
     /// Only public because it needs to be exposed to the Python layer.
     /// It is not the full `setparents` logic, only the parts that mutate the
     /// entries.
     pub fn setparents_fixup(
         &mut self,
     ) -> Result<Vec<(HgPathBuf, HgPathBuf)>, DirstateV2ParseError> {
         // XXX
         // All the copying and re-querying is quite inefficient, but this is
         // still a lot better than doing it from Python.
         //
         // The better solution is to develop a mechanism for `iter_mut`,
         // which will be a lot more involved: we're dealing with a lazy,
         // append-mostly, tree-like data structure. This will do for now.
         let mut copies = vec![];
         let mut files_with_p2_info = vec![];
         for res in self.iter() {
             let (path, entry) = res?;
             if entry.p2_info() {
                 files_with_p2_info.push(path.to_owned())
             }
         }
         self.with_dmap_mut(|map| {
             for path in files_with_p2_info.iter() {
                 let node = map.get_or_insert_node(path, |_| {})?;
                 let entry =
                     node.data.as_entry_mut().expect("entry should exist");
                 entry.drop_merge_data();
                 if let Some(source) = node.copy_source.take().as_deref() {
                     copies.push((path.to_owned(), source.to_owned()));
                 }
             }
             Ok(copies)
         })
     }
 
     pub fn debug_iter(
         &self,
         all: bool,
     ) -> Box<
         dyn Iterator<Item = Result<DebugDirstateTuple, DirstateV2ParseError>>
             + Send
             + '_,
     > {
         let map = self.get_map();
         Box::new(filter_map_results(map.iter_nodes(), move |node| {
             let debug_tuple = if let Some(entry) = node.entry()? {
                 entry.debug_tuple()
             } else if !all {
                 return Ok(None);
             } else if let Some(mtime) = node.cached_directory_mtime()? {
                 (b' ', 0, -1, mtime.truncated_seconds() as i32)
             } else {
                 (b' ', 0, -1, -1)
             };
             Ok(Some((node.full_path(map.on_disk)?, debug_tuple)))
         }))
     }
 }
 #[cfg(test)]
 mod tests {
     use super::*;
 
     /// Shortcut to return tracked descendants of a path.
     /// Panics if the path does not exist.
     fn tracked_descendants(map: &OwningDirstateMap, path: &[u8]) -> u32 {
         let path = dbg!(HgPath::new(path));
         let node = map.get_map().get_node(path);
         node.unwrap().unwrap().tracked_descendants_count()
     }
 
     /// Shortcut to return descendants with an entry.
     /// Panics if the path does not exist.
     fn descendants_with_an_entry(map: &OwningDirstateMap, path: &[u8]) -> u32 {
         let path = dbg!(HgPath::new(path));
         let node = map.get_map().get_node(path);
         node.unwrap().unwrap().descendants_with_entry_count()
     }
 
     fn assert_does_not_exist(map: &OwningDirstateMap, path: &[u8]) {
         let path = dbg!(HgPath::new(path));
         let node = map.get_map().get_node(path);
         assert!(node.unwrap().is_none());
     }
 
     /// Shortcut for path creation in tests
     fn p(b: &[u8]) -> &HgPath {
         HgPath::new(b)
     }
 
     /// Test the very simple case a single tracked file
     #[test]
     fn test_tracked_descendants_simple() -> Result<(), DirstateError> {
         let mut map = OwningDirstateMap::new_empty(vec![]);
         assert_eq!(map.len(), 0);
 
         map.set_tracked(p(b"some/nested/path"))?;
 
         assert_eq!(map.len(), 1);
         assert_eq!(tracked_descendants(&map, b"some"), 1);
         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);
         assert_eq!(tracked_descendants(&map, b"some/nested/path"), 0);
 
         map.set_untracked(p(b"some/nested/path"))?;
         assert_eq!(map.len(), 0);
         assert!(map.get_map().get_node(p(b"some"))?.is_none());
 
         Ok(())
     }
 
     /// Test the simple case of all tracked, but multiple files
     #[test]
     fn test_tracked_descendants_multiple() -> Result<(), DirstateError> {
         let mut map = OwningDirstateMap::new_empty(vec![]);
 
         map.set_tracked(p(b"some/nested/path"))?;
         map.set_tracked(p(b"some/nested/file"))?;
         // one layer without any files to test deletion cascade
         map.set_tracked(p(b"some/other/nested/path"))?;
         map.set_tracked(p(b"root_file"))?;
         map.set_tracked(p(b"some/file"))?;
         map.set_tracked(p(b"some/file2"))?;
         map.set_tracked(p(b"some/file3"))?;
 
         assert_eq!(map.len(), 7);
         assert_eq!(tracked_descendants(&map, b"some"), 6);
         assert_eq!(tracked_descendants(&map, b"some/nested"), 2);
         assert_eq!(tracked_descendants(&map, b"some/other"), 1);
         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);
         assert_eq!(tracked_descendants(&map, b"some/nested/path"), 0);
 
         map.set_untracked(p(b"some/nested/path"))?;
         assert_eq!(map.len(), 6);
         assert_eq!(tracked_descendants(&map, b"some"), 5);
         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);
         assert_eq!(tracked_descendants(&map, b"some/other"), 1);
         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);
 
         map.set_untracked(p(b"some/nested/file"))?;
         assert_eq!(map.len(), 5);
         assert_eq!(tracked_descendants(&map, b"some"), 4);
         assert_eq!(tracked_descendants(&map, b"some/other"), 1);
         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);
         assert_does_not_exist(&map, b"some_nested");
 
         map.set_untracked(p(b"some/other/nested/path"))?;
         assert_eq!(map.len(), 4);
         assert_eq!(tracked_descendants(&map, b"some"), 3);
         assert_does_not_exist(&map, b"some/other");
 
         map.set_untracked(p(b"root_file"))?;
         assert_eq!(map.len(), 3);
         assert_eq!(tracked_descendants(&map, b"some"), 3);
         assert_does_not_exist(&map, b"root_file");
 
         map.set_untracked(p(b"some/file"))?;
         assert_eq!(map.len(), 2);
         assert_eq!(tracked_descendants(&map, b"some"), 2);
         assert_does_not_exist(&map, b"some/file");
 
         map.set_untracked(p(b"some/file2"))?;
         assert_eq!(map.len(), 1);
         assert_eq!(tracked_descendants(&map, b"some"), 1);
         assert_does_not_exist(&map, b"some/file2");
 
         map.set_untracked(p(b"some/file3"))?;
         assert_eq!(map.len(), 0);
         assert_does_not_exist(&map, b"some/file3");
 
         Ok(())
     }
 
     /// Check with a mix of tracked and non-tracked items
     #[test]
     fn test_tracked_descendants_different() -> Result<(), DirstateError> {
         let mut map = OwningDirstateMap::new_empty(vec![]);
 
         // A file that was just added
         map.set_tracked(p(b"some/nested/path"))?;
         // This has no information, the dirstate should ignore it
         map.reset_state(p(b"some/file"), false, false, false, false, None)?;
         assert_does_not_exist(&map, b"some/file");
 
         // A file that was removed
         map.reset_state(
             p(b"some/nested/file"),
             false,
             true,
             false,
             false,
             None,
         )?;
         assert!(!map.get(p(b"some/nested/file"))?.unwrap().tracked());
         // Only present in p2
         map.reset_state(p(b"some/file3"), false, false, true, false, None)?;
         assert!(!map.get(p(b"some/file3"))?.unwrap().tracked());
         // A file that was merged
         map.reset_state(p(b"root_file"), true, true, true, false, None)?;
         assert!(map.get(p(b"root_file"))?.unwrap().tracked());
         // A file that is added, with info from p2
         // XXX is that actually possible?
         map.reset_state(p(b"some/file2"), true, false, true, false, None)?;
         assert!(map.get(p(b"some/file2"))?.unwrap().tracked());
         // A clean file
         // One layer without any files to test deletion cascade
         map.reset_state(
             p(b"some/other/nested/path"),
             true,
             true,
             false,
             false,
             None,
         )?;
         assert!(map.get(p(b"some/other/nested/path"))?.unwrap().tracked());
 
         assert_eq!(map.len(), 6);
         assert_eq!(tracked_descendants(&map, b"some"), 3);
         assert_eq!(descendants_with_an_entry(&map, b"some"), 5);
         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some/other/nested"), 1);
         assert_eq!(tracked_descendants(&map, b"some/other/nested/path"), 0);
         assert_eq!(
             descendants_with_an_entry(&map, b"some/other/nested/path"),
             0
         );
         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 2);
 
         // might as well check this
         map.set_untracked(p(b"path/does/not/exist"))?;
         assert_eq!(map.len(), 6);
 
         map.set_untracked(p(b"some/other/nested/path"))?;
         // It is set untracked but not deleted since it held other information
         assert_eq!(map.len(), 6);
         assert_eq!(tracked_descendants(&map, b"some"), 2);
         assert_eq!(descendants_with_an_entry(&map, b"some"), 5);
         assert_eq!(descendants_with_an_entry(&map, b"some/other"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some/other/nested"), 1);
         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 2);
 
         map.set_untracked(p(b"some/nested/path"))?;
         // It is set untracked *and* deleted since it was only added
         assert_eq!(map.len(), 5);
         assert_eq!(tracked_descendants(&map, b"some"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some"), 4);
         assert_eq!(tracked_descendants(&map, b"some/nested"), 0);
         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 1);
         assert_does_not_exist(&map, b"some/nested/path");
 
         map.set_untracked(p(b"root_file"))?;
         // Untracked but not deleted
         assert_eq!(map.len(), 5);
         assert!(map.get(p(b"root_file"))?.is_some());
 
         map.set_untracked(p(b"some/file2"))?;
         assert_eq!(map.len(), 5);
         assert_eq!(tracked_descendants(&map, b"some"), 0);
         assert!(map.get(p(b"some/file2"))?.is_some());
 
         map.set_untracked(p(b"some/file3"))?;
         assert_eq!(map.len(), 5);
         assert_eq!(tracked_descendants(&map, b"some"), 0);
         assert!(map.get(p(b"some/file3"))?.is_some());
 
         Ok(())
     }
 
     /// Check that copies counter is correctly updated
     #[test]
     fn test_copy_source() -> Result<(), DirstateError> {
         let mut map = OwningDirstateMap::new_empty(vec![]);
 
         // Clean file
         map.reset_state(p(b"files/clean"), true, true, false, false, None)?;
         // Merged file
         map.reset_state(p(b"files/from_p2"), true, true, true, false, None)?;
         // Removed file
         map.reset_state(p(b"removed"), false, true, false, false, None)?;
         // Added file
         map.reset_state(p(b"files/added"), true, false, false, false, None)?;
         // Add copy
         map.copy_map_insert(p(b"files/clean"), p(b"clean_copy_source"))?;
         assert_eq!(map.copy_map_len(), 1);
 
         // Copy override
         map.copy_map_insert(p(b"files/clean"), p(b"other_clean_copy_source"))?;
         assert_eq!(map.copy_map_len(), 1);
 
         // Multiple copies
         map.copy_map_insert(p(b"removed"), p(b"removed_copy_source"))?;
         assert_eq!(map.copy_map_len(), 2);
 
         map.copy_map_insert(p(b"files/added"), p(b"added_copy_source"))?;
         assert_eq!(map.copy_map_len(), 3);
 
         // Added, so the entry is completely removed
         map.set_untracked(p(b"files/added"))?;
         assert_does_not_exist(&map, b"files/added");
         assert_eq!(map.copy_map_len(), 2);
 
         // Removed, so the entry is kept around, so is its copy
         map.set_untracked(p(b"removed"))?;
         assert!(map.get(p(b"removed"))?.is_some());
         assert_eq!(map.copy_map_len(), 2);
 
         // Clean, so the entry is kept around, but not its copy
         map.set_untracked(p(b"files/clean"))?;
         assert!(map.get(p(b"files/clean"))?.is_some());
         assert_eq!(map.copy_map_len(), 1);
 
         map.copy_map_insert(p(b"files/from_p2"), p(b"from_p2_copy_source"))?;
         assert_eq!(map.copy_map_len(), 2);
 
         // Info from p2, so its copy source info is kept around
         map.set_untracked(p(b"files/from_p2"))?;
         assert!(map.get(p(b"files/from_p2"))?.is_some());
         assert_eq!(map.copy_map_len(), 2);
 
         Ok(())
     }
 
     /// Test with "on disk" data. For the sake of this test, the "on disk" data
     /// does not actually come from the disk, but it's opaque to the code being
     /// tested.
     #[test]
     fn test_on_disk() -> Result<(), DirstateError> {
         // First let's create some data to put "on disk"
         let mut map = OwningDirstateMap::new_empty(vec![]);
 
         // A file that was just added
         map.set_tracked(p(b"some/nested/added"))?;
         map.copy_map_insert(p(b"some/nested/added"), p(b"added_copy_source"))?;
 
         // A file that was removed
         map.reset_state(
             p(b"some/nested/removed"),
             false,
             true,
             false,
             false,
             None,
         )?;
         // Only present in p2
         map.reset_state(
             p(b"other/p2_info_only"),
             false,
             false,
             true,
             false,
             None,
         )?;
         map.copy_map_insert(
             p(b"other/p2_info_only"),
             p(b"other/p2_info_copy_source"),
         )?;
         // A file that was merged
         map.reset_state(p(b"merged"), true, true, true, false, None)?;
         // A file that is added, with info from p2
         // XXX is that actually possible?
         map.reset_state(
             p(b"other/added_with_p2"),
             true,
             false,
             true,
             false,
             None,
         )?;
         // One layer without any files to test deletion cascade
         // A clean file
         map.reset_state(
             p(b"some/other/nested/clean"),
             true,
             true,
             false,
             false,
             None,
         )?;
 
         let (packed, metadata, _should_append, _old_data_size) =
             map.pack_v2(false)?;
         let packed_len = packed.len();
         assert!(packed_len > 0);
 
         // Recreate "from disk"
         let mut map = OwningDirstateMap::new_v2(
             packed,
             packed_len,
             metadata.as_bytes(),
         )?;
 
         // Check that everything is accounted for
         assert!(map.contains_key(p(b"some/nested/added"))?);
         assert!(map.contains_key(p(b"some/nested/removed"))?);
         assert!(map.contains_key(p(b"merged"))?);
         assert!(map.contains_key(p(b"other/p2_info_only"))?);
         assert!(map.contains_key(p(b"other/added_with_p2"))?);
         assert!(map.contains_key(p(b"some/other/nested/clean"))?);
         assert_eq!(
             map.copy_map_get(p(b"some/nested/added"))?,
             Some(p(b"added_copy_source"))
         );
         assert_eq!(
             map.copy_map_get(p(b"other/p2_info_only"))?,
             Some(p(b"other/p2_info_copy_source"))
         );
         assert_eq!(tracked_descendants(&map, b"some"), 2);
         assert_eq!(descendants_with_an_entry(&map, b"some"), 3);
         assert_eq!(tracked_descendants(&map, b"other"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"other"), 2);
         assert_eq!(tracked_descendants(&map, b"some/other"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some/other"), 1);
         assert_eq!(tracked_descendants(&map, b"some/other/nested"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some/other/nested"), 1);
         assert_eq!(tracked_descendants(&map, b"some/nested"), 1);
         assert_eq!(descendants_with_an_entry(&map, b"some/nested"), 2);
         assert_eq!(map.len(), 6);
         assert_eq!(map.get_map().unreachable_bytes, 0);
         assert_eq!(map.copy_map_len(), 2);
 
         // Shouldn't change anything since it's already not tracked
         map.set_untracked(p(b"some/nested/removed"))?;
         assert_eq!(map.get_map().unreachable_bytes, 0);
 
-        match map.get_map().root {
-            ChildNodes::InMemory(_) => {
-                panic!("root should not have been mutated")
-            }
-            _ => (),
+        if let ChildNodes::InMemory(_) = map.get_map().root {
+            panic!("root should not have been mutated")
         }
         // We haven't mutated enough (nothing, actually), we should still be in
         // the append strategy
         assert!(map.get_map().write_should_append());
 
         // But this mutates the structure, so there should be unreachable_bytes
         assert!(map.set_untracked(p(b"some/nested/added"))?);
         let unreachable_bytes = map.get_map().unreachable_bytes;
         assert!(unreachable_bytes > 0);
 
-        match map.get_map().root {
-            ChildNodes::OnDisk(_) => panic!("root should have been mutated"),
-            _ => (),
+        if let ChildNodes::OnDisk(_) = map.get_map().root {
+            panic!("root should have been mutated")
         }
 
         // This should not mutate the structure either, since `root` has
         // already been mutated along with its direct children.
         map.set_untracked(p(b"merged"))?;
         assert_eq!(map.get_map().unreachable_bytes, unreachable_bytes);
 
-        match map.get_map().get_node(p(b"other/added_with_p2"))?.unwrap() {
-            NodeRef::InMemory(_, _) => {
-                panic!("'other/added_with_p2' should not have been mutated")
-            }
-            _ => (),
+        if let NodeRef::InMemory(_, _) =
+            map.get_map().get_node(p(b"other/added_with_p2"))?.unwrap()
+        {
+            panic!("'other/added_with_p2' should not have been mutated")
         }
         // But this should, since it's in a different path
         // than `<root>some/nested/add`
         map.set_untracked(p(b"other/added_with_p2"))?;
         assert!(map.get_map().unreachable_bytes > unreachable_bytes);
 
-        match map.get_map().get_node(p(b"other/added_with_p2"))?.unwrap() {
-            NodeRef::OnDisk(_) => {
-                panic!("'other/added_with_p2' should have been mutated")
-            }
-            _ => (),
+        if let NodeRef::OnDisk(_) =
+            map.get_map().get_node(p(b"other/added_with_p2"))?.unwrap()
+        {
+            panic!("'other/added_with_p2' should have been mutated")
         }
 
         // We have rewritten most of the tree, we should create a new file
         assert!(!map.get_map().write_should_append());
 
         Ok(())
     }
 }

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

@@ -1,877 +1,875 b''
 //! The "version 2" disk representation of the dirstate
 //!
 //! See `mercurial/helptext/internals/dirstate-v2.txt`
 
 use crate::dirstate::{DirstateV2Data, TruncatedTimestamp};
 use crate::dirstate_tree::dirstate_map::DirstateVersion;
 use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef};
 use crate::dirstate_tree::path_with_basename::WithBasename;
 use crate::errors::HgError;
 use crate::utils::hg_path::HgPath;
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateParents;
 use bitflags::bitflags;
 use bytes_cast::unaligned::{U16Be, U32Be};
 use bytes_cast::BytesCast;
 use format_bytes::format_bytes;
 use rand::Rng;
 use std::borrow::Cow;
 use std::fmt::Write;
 
 /// Added at the start of `.hg/dirstate` when the "v2" format is used.
 /// This a redundant sanity check more than an actual "magic number" since
 /// `.hg/requires` already governs which format should be used.
 pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n";
 
 /// Keep space for 256-bit hashes
 const STORED_NODE_ID_BYTES: usize = 32;
 
 /// … even though only 160 bits are used for now, with SHA-1
 const USED_NODE_ID_BYTES: usize = 20;
 
 pub(super) const IGNORE_PATTERNS_HASH_LEN: usize = 20;
 pub(super) type IgnorePatternsHash = [u8; IGNORE_PATTERNS_HASH_LEN];
 
 /// Must match constants of the same names in `mercurial/dirstateutils/v2.py`
 const TREE_METADATA_SIZE: usize = 44;
 const NODE_SIZE: usize = 44;
 
 /// Make sure that size-affecting changes are made knowingly
 #[allow(unused)]
 fn static_assert_size_of() {
     let _ = std::mem::transmute::<TreeMetadata, [u8; TREE_METADATA_SIZE]>;
     let _ = std::mem::transmute::<DocketHeader, [u8; TREE_METADATA_SIZE + 81]>;
     let _ = std::mem::transmute::<Node, [u8; NODE_SIZE]>;
 }
 
 // Must match `HEADER` in `mercurial/dirstateutils/docket.py`
 #[derive(BytesCast)]
 #[repr(C)]
 struct DocketHeader {
     marker: [u8; V2_FORMAT_MARKER.len()],
     parent_1: [u8; STORED_NODE_ID_BYTES],
     parent_2: [u8; STORED_NODE_ID_BYTES],
 
     metadata: TreeMetadata,
 
     /// Counted in bytes
     data_size: Size,
 
     uuid_size: u8,
 }
 
 pub struct Docket<'on_disk> {
     header: &'on_disk DocketHeader,
     pub uuid: &'on_disk [u8],
 }
 
 /// Fields are documented in the *Tree metadata in the docket file*
 /// section of `mercurial/helptext/internals/dirstate-v2.txt`
 #[derive(BytesCast)]
 #[repr(C)]
 pub struct TreeMetadata {
     root_nodes: ChildNodes,
     nodes_with_entry_count: Size,
     nodes_with_copy_source_count: Size,
     unreachable_bytes: Size,
     unused: [u8; 4],
 
     /// See *Optional hash of ignore patterns* section of
     /// `mercurial/helptext/internals/dirstate-v2.txt`
     ignore_patterns_hash: IgnorePatternsHash,
 }
 
 /// Fields are documented in the *The data file format*
 /// section of `mercurial/helptext/internals/dirstate-v2.txt`
 #[derive(BytesCast, Debug)]
 #[repr(C)]
 pub(super) struct Node {
     full_path: PathSlice,
 
     /// In bytes from `self.full_path.start`
     base_name_start: PathSize,
 
     copy_source: OptPathSlice,
     children: ChildNodes,
     pub(super) descendants_with_entry_count: Size,
     pub(super) tracked_descendants_count: Size,
     flags: U16Be,
     size: U32Be,
     mtime: PackedTruncatedTimestamp,
 }
 
 bitflags! {
     #[repr(C)]
     struct Flags: u16 {
         const WDIR_TRACKED = 1 << 0;
         const P1_TRACKED = 1 << 1;
         const P2_INFO = 1 << 2;
         const MODE_EXEC_PERM = 1 << 3;
         const MODE_IS_SYMLINK = 1 << 4;
         const HAS_FALLBACK_EXEC = 1 <<  5;
         const FALLBACK_EXEC = 1 <<  6;
         const HAS_FALLBACK_SYMLINK = 1 <<  7;
         const FALLBACK_SYMLINK = 1 <<  8;
         const EXPECTED_STATE_IS_MODIFIED = 1 << 9;
         const HAS_MODE_AND_SIZE = 1 <<10;
         const HAS_MTIME = 1 <<11;
         const MTIME_SECOND_AMBIGUOUS = 1 << 12;
         const DIRECTORY = 1 <<13;
         const ALL_UNKNOWN_RECORDED = 1 <<14;
         const ALL_IGNORED_RECORDED = 1 <<15;
     }
 }
 
 /// Duration since the Unix epoch
 #[derive(BytesCast, Copy, Clone, Debug)]
 #[repr(C)]
 struct PackedTruncatedTimestamp {
     truncated_seconds: U32Be,
     nanoseconds: U32Be,
 }
 
 /// Counted in bytes from the start of the file
 ///
 /// NOTE: not supporting `.hg/dirstate` files larger than 4 GiB.
 type Offset = U32Be;
 
 /// Counted in number of items
 ///
 /// NOTE: we choose not to support counting more than 4 billion nodes anywhere.
 type Size = U32Be;
 
 /// Counted in bytes
 ///
 /// NOTE: we choose not to support file names/paths longer than 64 KiB.
 type PathSize = U16Be;
 
 /// A contiguous sequence of `len` times `Node`, representing the child nodes
 /// of either some other node or of the repository root.
 ///
 /// Always sorted by ascending `full_path`, to allow binary search.
 /// Since nodes with the same parent nodes also have the same parent path,
 /// only the `base_name`s need to be compared during binary search.
 #[derive(BytesCast, Copy, Clone, Debug)]
 #[repr(C)]
 struct ChildNodes {
     start: Offset,
     len: Size,
 }
 
 /// A `HgPath` of `len` bytes
 #[derive(BytesCast, Copy, Clone, Debug)]
 #[repr(C)]
 struct PathSlice {
     start: Offset,
     len: PathSize,
 }
 
 /// Either nothing if `start == 0`, or a `HgPath` of `len` bytes
 type OptPathSlice = PathSlice;
 
 /// Unexpected file format found in `.hg/dirstate` with the "v2" format.
 ///
 /// This should only happen if Mercurial is buggy or a repository is corrupted.
 #[derive(Debug)]
 pub struct DirstateV2ParseError {
     message: String,
 }
 
 impl DirstateV2ParseError {
     pub fn new<S: Into<String>>(message: S) -> Self {
         Self {
             message: message.into(),
         }
     }
 }
 
 impl From<DirstateV2ParseError> for HgError {
     fn from(e: DirstateV2ParseError) -> Self {
         HgError::corrupted(format!("dirstate-v2 parse error: {}", e.message))
     }
 }
 
 impl From<DirstateV2ParseError> for crate::DirstateError {
     fn from(error: DirstateV2ParseError) -> Self {
         HgError::from(error).into()
     }
 }
 
 impl TreeMetadata {
     pub fn as_bytes(&self) -> &[u8] {
         BytesCast::as_bytes(self)
     }
 }
 
 impl<'on_disk> Docket<'on_disk> {
     /// Generate the identifier for a new data file
     ///
     /// TODO: support the `HGTEST_UUIDFILE` environment variable.
     /// See `mercurial/revlogutils/docket.py`
     pub fn new_uid() -> String {
         const ID_LENGTH: usize = 8;
         let mut id = String::with_capacity(ID_LENGTH);
         let mut rng = rand::thread_rng();
         for _ in 0..ID_LENGTH {
             // One random hexadecimal digit.
             // `unwrap` never panics because `impl Write for String`
             // never returns an error.
             write!(&mut id, "{:x}", rng.gen_range(0..16)).unwrap();
         }
         id
     }
 
     pub fn serialize(
         parents: DirstateParents,
         tree_metadata: TreeMetadata,
         data_size: u64,
         uuid: &[u8],
     ) -> Result<Vec<u8>, std::num::TryFromIntError> {
         let header = DocketHeader {
             marker: *V2_FORMAT_MARKER,
             parent_1: parents.p1.pad_to_256_bits(),
             parent_2: parents.p2.pad_to_256_bits(),
             metadata: tree_metadata,
             data_size: u32::try_from(data_size)?.into(),
             uuid_size: uuid.len().try_into()?,
         };
         let header = header.as_bytes();
         let mut docket = Vec::with_capacity(header.len() + uuid.len());
         docket.extend_from_slice(header);
         docket.extend_from_slice(uuid);
         Ok(docket)
     }
 
     pub fn parents(&self) -> DirstateParents {
         use crate::Node;
         let p1 = Node::try_from(&self.header.parent_1[..USED_NODE_ID_BYTES])
-            .unwrap()
-            .clone();
+            .unwrap();
         let p2 = Node::try_from(&self.header.parent_2[..USED_NODE_ID_BYTES])
-            .unwrap()
-            .clone();
+            .unwrap();
         DirstateParents { p1, p2 }
     }
 
     pub fn tree_metadata(&self) -> &[u8] {
         self.header.metadata.as_bytes()
     }
 
     pub fn data_size(&self) -> usize {
         // This `unwrap` could only panic on a 16-bit CPU
         self.header.data_size.get().try_into().unwrap()
     }
 
     pub fn data_filename(&self) -> String {
         String::from_utf8(format_bytes!(b"dirstate.{}", self.uuid)).unwrap()
     }
 }
 
 pub fn read_docket(
     on_disk: &[u8],
 ) -> Result<Docket<'_>, DirstateV2ParseError> {
     let (header, uuid) = DocketHeader::from_bytes(on_disk).map_err(|e| {
         DirstateV2ParseError::new(format!("when reading docket, {}", e))
     })?;
     let uuid_size = header.uuid_size as usize;
     if header.marker == *V2_FORMAT_MARKER && uuid.len() == uuid_size {
         Ok(Docket { header, uuid })
     } else {
         Err(DirstateV2ParseError::new(
             "invalid format marker or uuid size",
         ))
     }
 }
 
 pub(super) fn read<'on_disk>(
     on_disk: &'on_disk [u8],
     metadata: &[u8],
 ) -> Result<DirstateMap<'on_disk>, DirstateV2ParseError> {
     if on_disk.is_empty() {
         let mut map = DirstateMap::empty(on_disk);
         map.dirstate_version = DirstateVersion::V2;
         return Ok(map);
     }
     let (meta, _) = TreeMetadata::from_bytes(metadata).map_err(|e| {
         DirstateV2ParseError::new(format!("when parsing tree metadata, {}", e))
     })?;
     let dirstate_map = DirstateMap {
         on_disk,
         root: dirstate_map::ChildNodes::OnDisk(
             read_nodes(on_disk, meta.root_nodes).map_err(|mut e| {
                 e.message = format!("{}, when reading root notes", e.message);
                 e
             })?,
         ),
         nodes_with_entry_count: meta.nodes_with_entry_count.get(),
         nodes_with_copy_source_count: meta.nodes_with_copy_source_count.get(),
         ignore_patterns_hash: meta.ignore_patterns_hash,
         unreachable_bytes: meta.unreachable_bytes.get(),
         old_data_size: on_disk.len(),
         dirstate_version: DirstateVersion::V2,
     };
     Ok(dirstate_map)
 }
 
 impl Node {
     pub(super) fn full_path<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
         read_hg_path(on_disk, self.full_path)
     }
 
-    pub(super) fn base_name_start<'on_disk>(
+    pub(super) fn base_name_start(
         &self,
     ) -> Result<usize, DirstateV2ParseError> {
         let start = self.base_name_start.get();
         if start < self.full_path.len.get() {
             let start = usize::try_from(start)
                 // u32 -> usize, could only panic on a 16-bit CPU
                 .expect("dirstate-v2 base_name_start out of bounds");
             Ok(start)
         } else {
             Err(DirstateV2ParseError::new("not enough bytes for base name"))
         }
     }
 
     pub(super) fn base_name<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
         let full_path = self.full_path(on_disk)?;
         let base_name_start = self.base_name_start()?;
         Ok(HgPath::new(&full_path.as_bytes()[base_name_start..]))
     }
 
     pub(super) fn path<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<dirstate_map::NodeKey<'on_disk>, DirstateV2ParseError> {
         Ok(WithBasename::from_raw_parts(
             Cow::Borrowed(self.full_path(on_disk)?),
             self.base_name_start()?,
         ))
     }
 
-    pub(super) fn has_copy_source<'on_disk>(&self) -> bool {
+    pub(super) fn has_copy_source(&self) -> bool {
         self.copy_source.start.get() != 0
     }
 
     pub(super) fn copy_source<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<&'on_disk HgPath>, DirstateV2ParseError> {
         Ok(if self.has_copy_source() {
             Some(read_hg_path(on_disk, self.copy_source)?)
         } else {
             None
         })
     }
 
     fn flags(&self) -> Flags {
         Flags::from_bits_truncate(self.flags.get())
     }
 
     fn has_entry(&self) -> bool {
         self.flags().intersects(
             Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO,
         )
     }
 
     pub(super) fn node_data(
         &self,
     ) -> Result<dirstate_map::NodeData, DirstateV2ParseError> {
         if self.has_entry() {
             Ok(dirstate_map::NodeData::Entry(self.assume_entry()?))
         } else if let Some(mtime) = self.cached_directory_mtime()? {
             Ok(dirstate_map::NodeData::CachedDirectory { mtime })
         } else {
             Ok(dirstate_map::NodeData::None)
         }
     }
 
     pub(super) fn cached_directory_mtime(
         &self,
     ) -> Result<Option<TruncatedTimestamp>, DirstateV2ParseError> {
         // For now we do not have code to handle the absence of
         // ALL_UNKNOWN_RECORDED, so we ignore the mtime if the flag is
         // unset.
         if self.flags().contains(Flags::DIRECTORY)
             && self.flags().contains(Flags::HAS_MTIME)
             && self.flags().contains(Flags::ALL_UNKNOWN_RECORDED)
         {
             Ok(Some(self.mtime()?))
         } else {
             Ok(None)
         }
     }
 
     fn synthesize_unix_mode(&self) -> u32 {
         let file_type = if self.flags().contains(Flags::MODE_IS_SYMLINK) {
             libc::S_IFLNK
         } else {
             libc::S_IFREG
         };
-        let permisions = if self.flags().contains(Flags::MODE_EXEC_PERM) {
+        let permissions = if self.flags().contains(Flags::MODE_EXEC_PERM) {
             0o755
         } else {
             0o644
         };
-        (file_type | permisions).into()
+        file_type | permissions
     }
 
     fn mtime(&self) -> Result<TruncatedTimestamp, DirstateV2ParseError> {
         let mut m: TruncatedTimestamp = self.mtime.try_into()?;
         if self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS) {
             m.second_ambiguous = true;
         }
         Ok(m)
     }
 
     fn assume_entry(&self) -> Result<DirstateEntry, DirstateV2ParseError> {
         // TODO: convert through raw bits instead?
         let wc_tracked = self.flags().contains(Flags::WDIR_TRACKED);
         let p1_tracked = self.flags().contains(Flags::P1_TRACKED);
         let p2_info = self.flags().contains(Flags::P2_INFO);
         let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE)
             && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
         {
             Some((self.synthesize_unix_mode(), self.size.into()))
         } else {
             None
         };
         let mtime = if self.flags().contains(Flags::HAS_MTIME)
             && !self.flags().contains(Flags::DIRECTORY)
             && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
         {
             Some(self.mtime()?)
         } else {
             None
         };
         let fallback_exec = if self.flags().contains(Flags::HAS_FALLBACK_EXEC)
         {
             Some(self.flags().contains(Flags::FALLBACK_EXEC))
         } else {
             None
         };
         let fallback_symlink =
             if self.flags().contains(Flags::HAS_FALLBACK_SYMLINK) {
                 Some(self.flags().contains(Flags::FALLBACK_SYMLINK))
             } else {
                 None
             };
         Ok(DirstateEntry::from_v2_data(DirstateV2Data {
             wc_tracked,
             p1_tracked,
             p2_info,
             mode_size,
             mtime,
             fallback_exec,
             fallback_symlink,
         }))
     }
 
     pub(super) fn entry(
         &self,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         if self.has_entry() {
             Ok(Some(self.assume_entry()?))
         } else {
             Ok(None)
         }
     }
 
     pub(super) fn children<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk [Node], DirstateV2ParseError> {
         read_nodes(on_disk, self.children)
     }
 
     pub(super) fn to_in_memory_node<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<dirstate_map::Node<'on_disk>, DirstateV2ParseError> {
         Ok(dirstate_map::Node {
             children: dirstate_map::ChildNodes::OnDisk(
                 self.children(on_disk)?,
             ),
             copy_source: self.copy_source(on_disk)?.map(Cow::Borrowed),
             data: self.node_data()?,
             descendants_with_entry_count: self
                 .descendants_with_entry_count
                 .get(),
             tracked_descendants_count: self.tracked_descendants_count.get(),
         })
     }
 
     fn from_dirstate_entry(
         entry: &DirstateEntry,
     ) -> (Flags, U32Be, PackedTruncatedTimestamp) {
         let DirstateV2Data {
             wc_tracked,
             p1_tracked,
             p2_info,
             mode_size: mode_size_opt,
             mtime: mtime_opt,
             fallback_exec,
             fallback_symlink,
         } = entry.v2_data();
         // TODO: convert through raw flag bits instead?
         let mut flags = Flags::empty();
         flags.set(Flags::WDIR_TRACKED, wc_tracked);
         flags.set(Flags::P1_TRACKED, p1_tracked);
         flags.set(Flags::P2_INFO, p2_info);
         let size = if let Some((m, s)) = mode_size_opt {
             let exec_perm = m & (libc::S_IXUSR as u32) != 0;
             let is_symlink = m & (libc::S_IFMT as u32) == libc::S_IFLNK as u32;
             flags.set(Flags::MODE_EXEC_PERM, exec_perm);
             flags.set(Flags::MODE_IS_SYMLINK, is_symlink);
             flags.insert(Flags::HAS_MODE_AND_SIZE);
             s.into()
         } else {
             0.into()
         };
         let mtime = if let Some(m) = mtime_opt {
             flags.insert(Flags::HAS_MTIME);
             if m.second_ambiguous {
                 flags.insert(Flags::MTIME_SECOND_AMBIGUOUS);
             };
             m.into()
         } else {
             PackedTruncatedTimestamp::null()
         };
         if let Some(f_exec) = fallback_exec {
             flags.insert(Flags::HAS_FALLBACK_EXEC);
             if f_exec {
                 flags.insert(Flags::FALLBACK_EXEC);
             }
         }
         if let Some(f_symlink) = fallback_symlink {
             flags.insert(Flags::HAS_FALLBACK_SYMLINK);
             if f_symlink {
                 flags.insert(Flags::FALLBACK_SYMLINK);
             }
         }
         (flags, size, mtime)
     }
 }
 
 fn read_hg_path(
     on_disk: &[u8],
     slice: PathSlice,
 ) -> Result<&HgPath, DirstateV2ParseError> {
     read_slice(on_disk, slice.start, slice.len.get()).map(HgPath::new)
 }
 
 fn read_nodes(
     on_disk: &[u8],
     slice: ChildNodes,
 ) -> Result<&[Node], DirstateV2ParseError> {
     read_slice(on_disk, slice.start, slice.len.get())
 }
 
 fn read_slice<T, Len>(
     on_disk: &[u8],
     start: Offset,
     len: Len,
 ) -> Result<&[T], DirstateV2ParseError>
 where
     T: BytesCast,
     Len: TryInto<usize>,
 {
     // Either `usize::MAX` would result in "out of bounds" error since a single
     // `&[u8]` cannot occupy the entire addess space.
     let start = start.get().try_into().unwrap_or(std::usize::MAX);
     let len = len.try_into().unwrap_or(std::usize::MAX);
     let bytes = match on_disk.get(start..) {
         Some(bytes) => bytes,
         None => {
             return Err(DirstateV2ParseError::new(
                 "not enough bytes from disk",
             ))
         }
     };
     T::slice_from_bytes(bytes, len)
         .map_err(|e| {
             DirstateV2ParseError::new(format!("when reading a slice, {}", e))
         })
         .map(|(slice, _rest)| slice)
 }
 
 pub(crate) fn for_each_tracked_path<'on_disk>(
     on_disk: &'on_disk [u8],
     metadata: &[u8],
     mut f: impl FnMut(&'on_disk HgPath),
 ) -> Result<(), DirstateV2ParseError> {
     let (meta, _) = TreeMetadata::from_bytes(metadata).map_err(|e| {
         DirstateV2ParseError::new(format!("when parsing tree metadata, {}", e))
     })?;
     fn recur<'on_disk>(
         on_disk: &'on_disk [u8],
         nodes: ChildNodes,
         f: &mut impl FnMut(&'on_disk HgPath),
     ) -> Result<(), DirstateV2ParseError> {
         for node in read_nodes(on_disk, nodes)? {
             if let Some(entry) = node.entry()? {
                 if entry.tracked() {
                     f(node.full_path(on_disk)?)
                 }
             }
             recur(on_disk, node.children, f)?
         }
         Ok(())
     }
     recur(on_disk, meta.root_nodes, &mut f)
 }
 
 /// Returns new data and metadata, together with whether that data should be
 /// appended to the existing data file whose content is at
 /// `dirstate_map.on_disk` (true), instead of written to a new data file
 /// (false), and the previous size of data on disk.
 pub(super) fn write(
     dirstate_map: &DirstateMap,
     can_append: bool,
 ) -> Result<(Vec<u8>, TreeMetadata, bool, usize), DirstateError> {
     let append = can_append && dirstate_map.write_should_append();
 
     // This ignores the space for paths, and for nodes without an entry.
     // TODO: better estimate? Skip the `Vec` and write to a file directly?
     let size_guess = std::mem::size_of::<Node>()
         * dirstate_map.nodes_with_entry_count as usize;
 
     let mut writer = Writer {
         dirstate_map,
         append,
         out: Vec::with_capacity(size_guess),
     };
 
     let root_nodes = writer.write_nodes(dirstate_map.root.as_ref())?;
 
     let unreachable_bytes = if append {
         dirstate_map.unreachable_bytes
     } else {
         0
     };
     let meta = TreeMetadata {
         root_nodes,
         nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(),
         nodes_with_copy_source_count: dirstate_map
             .nodes_with_copy_source_count
             .into(),
         unreachable_bytes: unreachable_bytes.into(),
         unused: [0; 4],
         ignore_patterns_hash: dirstate_map.ignore_patterns_hash,
     };
     Ok((writer.out, meta, append, dirstate_map.old_data_size))
 }
 
 struct Writer<'dmap, 'on_disk> {
     dirstate_map: &'dmap DirstateMap<'on_disk>,
     append: bool,
     out: Vec<u8>,
 }
 
 impl Writer<'_, '_> {
     fn write_nodes(
         &mut self,
         nodes: dirstate_map::ChildNodesRef,
     ) -> Result<ChildNodes, DirstateError> {
         // Reuse already-written nodes if possible
         if self.append {
             if let dirstate_map::ChildNodesRef::OnDisk(nodes_slice) = nodes {
                 let start = self.on_disk_offset_of(nodes_slice).expect(
                     "dirstate-v2 OnDisk nodes not found within on_disk",
                 );
                 let len = child_nodes_len_from_usize(nodes_slice.len());
                 return Ok(ChildNodes { start, len });
             }
         }
 
         // `dirstate_map::ChildNodes::InMemory` contains a `HashMap` which has
         // undefined iteration order. Sort to enable binary search in the
         // written file.
         let nodes = nodes.sorted();
         let nodes_len = nodes.len();
 
         // First accumulate serialized nodes in a `Vec`
         let mut on_disk_nodes = Vec::with_capacity(nodes_len);
         for node in nodes {
             let children =
                 self.write_nodes(node.children(self.dirstate_map.on_disk)?)?;
             let full_path = node.full_path(self.dirstate_map.on_disk)?;
             let full_path = self.write_path(full_path.as_bytes());
             let copy_source = if let Some(source) =
                 node.copy_source(self.dirstate_map.on_disk)?
             {
                 self.write_path(source.as_bytes())
             } else {
                 PathSlice {
                     start: 0.into(),
                     len: 0.into(),
                 }
             };
             on_disk_nodes.push(match node {
                 NodeRef::InMemory(path, node) => {
                     let (flags, size, mtime) = match &node.data {
                         dirstate_map::NodeData::Entry(entry) => {
                             Node::from_dirstate_entry(entry)
                         }
                         dirstate_map::NodeData::CachedDirectory { mtime } => {
                             // we currently never set a mtime if unknown file
                             // are present.
                             // So if we have a mtime for a directory, we know
                             // they are no unknown
                             // files and we
                             // blindly set ALL_UNKNOWN_RECORDED.
                             //
                             // We never set ALL_IGNORED_RECORDED since we
                             // don't track that case
                             // currently.
                             let mut flags = Flags::DIRECTORY
                                 | Flags::HAS_MTIME
                                 | Flags::ALL_UNKNOWN_RECORDED;
                             if mtime.second_ambiguous {
                                 flags.insert(Flags::MTIME_SECOND_AMBIGUOUS)
                             }
                             (flags, 0.into(), (*mtime).into())
                         }
                         dirstate_map::NodeData::None => (
                             Flags::DIRECTORY,
                             0.into(),
                             PackedTruncatedTimestamp::null(),
                         ),
                     };
                     Node {
                         children,
                         copy_source,
                         full_path,
                         base_name_start: u16::try_from(path.base_name_start())
                             // Could only panic for paths over 64 KiB
                             .expect("dirstate-v2 path length overflow")
                             .into(),
                         descendants_with_entry_count: node
                             .descendants_with_entry_count
                             .into(),
                         tracked_descendants_count: node
                             .tracked_descendants_count
                             .into(),
                         flags: flags.bits().into(),
                         size,
                         mtime,
                     }
                 }
                 NodeRef::OnDisk(node) => Node {
                     children,
                     copy_source,
                     full_path,
                     ..*node
                 },
             })
         }
         // … so we can write them contiguously, after writing everything else
         // they refer to.
         let start = self.current_offset();
         let len = child_nodes_len_from_usize(nodes_len);
         self.out.extend(on_disk_nodes.as_bytes());
         Ok(ChildNodes { start, len })
     }
 
     /// If the given slice of items is within `on_disk`, returns its offset
     /// from the start of `on_disk`.
     fn on_disk_offset_of<T>(&self, slice: &[T]) -> Option<Offset>
     where
         T: BytesCast,
     {
         fn address_range(slice: &[u8]) -> std::ops::RangeInclusive<usize> {
             let start = slice.as_ptr() as usize;
             let end = start + slice.len();
             start..=end
         }
         let slice_addresses = address_range(slice.as_bytes());
         let on_disk_addresses = address_range(self.dirstate_map.on_disk);
         if on_disk_addresses.contains(slice_addresses.start())
             && on_disk_addresses.contains(slice_addresses.end())
         {
             let offset = slice_addresses.start() - on_disk_addresses.start();
             Some(offset_from_usize(offset))
         } else {
             None
         }
     }
 
     fn current_offset(&mut self) -> Offset {
         let mut offset = self.out.len();
         if self.append {
             offset += self.dirstate_map.on_disk.len()
         }
         offset_from_usize(offset)
     }
 
     fn write_path(&mut self, slice: &[u8]) -> PathSlice {
         let len = path_len_from_usize(slice.len());
         // Reuse an already-written path if possible
         if self.append {
             if let Some(start) = self.on_disk_offset_of(slice) {
                 return PathSlice { start, len };
             }
         }
         let start = self.current_offset();
         self.out.extend(slice.as_bytes());
         PathSlice { start, len }
     }
 }
 
 fn offset_from_usize(x: usize) -> Offset {
     u32::try_from(x)
         // Could only panic for a dirstate file larger than 4 GiB
         .expect("dirstate-v2 offset overflow")
         .into()
 }
 
 fn child_nodes_len_from_usize(x: usize) -> Size {
     u32::try_from(x)
         // Could only panic with over 4 billion nodes
         .expect("dirstate-v2 slice length overflow")
         .into()
 }
 
 fn path_len_from_usize(x: usize) -> PathSize {
     u16::try_from(x)
         // Could only panic for paths over 64 KiB
         .expect("dirstate-v2 path length overflow")
         .into()
 }
 
 impl From<TruncatedTimestamp> for PackedTruncatedTimestamp {
     fn from(timestamp: TruncatedTimestamp) -> Self {
         Self {
             truncated_seconds: timestamp.truncated_seconds().into(),
             nanoseconds: timestamp.nanoseconds().into(),
         }
     }
 }
 
 impl TryFrom<PackedTruncatedTimestamp> for TruncatedTimestamp {
     type Error = DirstateV2ParseError;
 
     fn try_from(
         timestamp: PackedTruncatedTimestamp,
     ) -> Result<Self, Self::Error> {
         Self::from_already_truncated(
             timestamp.truncated_seconds.get(),
             timestamp.nanoseconds.get(),
             false,
         )
     }
 }
 impl PackedTruncatedTimestamp {
     fn null() -> Self {
         Self {
             truncated_seconds: 0.into(),
             nanoseconds: 0.into(),
         }
     }
 }

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

@@ -1,89 +1,89 b''
 use crate::{DirstateError, DirstateParents};
 
 use super::dirstate_map::DirstateMap;
 use std::ops::Deref;
 
 use ouroboros::self_referencing;
 
 /// Keep a `DirstateMap<'on_disk>` next to the `on_disk` buffer that it
 /// borrows.
 #[self_referencing]
 pub struct OwningDirstateMap {
     on_disk: Box<dyn Deref<Target = [u8]> + Send>,
     #[borrows(on_disk)]
     #[covariant]
     map: DirstateMap<'this>,
 }
 
 impl OwningDirstateMap {
     pub fn new_empty<OnDisk>(on_disk: OnDisk) -> Self
     where
         OnDisk: Deref<Target = [u8]> + Send + 'static,
     {
         let on_disk = Box::new(on_disk);
 
         OwningDirstateMapBuilder {
             on_disk,
-            map_builder: |bytes| DirstateMap::empty(&bytes),
+            map_builder: |bytes| DirstateMap::empty(bytes),
         }
         .build()
     }
 
     pub fn new_v1<OnDisk>(
         on_disk: OnDisk,
     ) -> Result<(Self, DirstateParents), DirstateError>
     where
         OnDisk: Deref<Target = [u8]> + Send + 'static,
     {
         let on_disk = Box::new(on_disk);
         let mut parents = DirstateParents::NULL;
 
         Ok((
             OwningDirstateMapTryBuilder {
                 on_disk,
                 map_builder: |bytes| {
-                    DirstateMap::new_v1(&bytes).map(|(dmap, p)| {
+                    DirstateMap::new_v1(bytes).map(|(dmap, p)| {
                         parents = p.unwrap_or(DirstateParents::NULL);
                         dmap
                     })
                 },
             }
             .try_build()?,
             parents,
         ))
     }
 
     pub fn new_v2<OnDisk>(
         on_disk: OnDisk,
         data_size: usize,
         metadata: &[u8],
     ) -> Result<Self, DirstateError>
     where
         OnDisk: Deref<Target = [u8]> + Send + 'static,
     {
         let on_disk = Box::new(on_disk);
 
         OwningDirstateMapTryBuilder {
             on_disk,
             map_builder: |bytes| {
-                DirstateMap::new_v2(&bytes, data_size, metadata)
+                DirstateMap::new_v2(bytes, data_size, metadata)
             },
         }
         .try_build()
     }
 
     pub fn with_dmap_mut<R>(
         &mut self,
         f: impl FnOnce(&mut DirstateMap) -> R,
     ) -> R {
         self.with_map_mut(f)
     }
 
     pub fn get_map(&self) -> &DirstateMap {
         self.borrow_map()
     }
 
     pub fn on_disk(&self) -> &[u8] {
         self.borrow_on_disk()
     }
 }

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

@@ -1,1002 +1,996 b''
 use crate::dirstate::entry::TruncatedTimestamp;
 use crate::dirstate::status::IgnoreFnType;
 use crate::dirstate::status::StatusPath;
 use crate::dirstate_tree::dirstate_map::BorrowedPath;
 use crate::dirstate_tree::dirstate_map::ChildNodesRef;
 use crate::dirstate_tree::dirstate_map::DirstateMap;
 use crate::dirstate_tree::dirstate_map::DirstateVersion;
 use crate::dirstate_tree::dirstate_map::NodeRef;
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::matchers::get_ignore_function;
 use crate::matchers::Matcher;
 use crate::utils::files::get_bytes_from_os_string;
 use crate::utils::files::get_bytes_from_path;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::HgPath;
 use crate::BadMatch;
 use crate::DirstateStatus;
 use crate::HgPathCow;
 use crate::PatternFileWarning;
 use crate::StatusError;
 use crate::StatusOptions;
 use once_cell::sync::OnceCell;
 use rayon::prelude::*;
 use sha1::{Digest, Sha1};
 use std::borrow::Cow;
 use std::io;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Mutex;
 use std::time::SystemTime;
 
 /// Returns the status of the working directory compared to its parent
 /// changeset.
 ///
 /// This algorithm is based on traversing the filesystem tree (`fs` in function
 /// and variable names) and dirstate tree at the same time. The core of this
 /// traversal is the recursive `traverse_fs_directory_and_dirstate` function
 /// and its use of `itertools::merge_join_by`. When reaching a path that only
 /// exists in one of the two trees, depending on information requested by
 /// `options` we may need to traverse the remaining subtree.
 #[logging_timer::time("trace")]
 pub fn status<'dirstate>(
     dmap: &'dirstate mut DirstateMap,
     matcher: &(dyn Matcher + Sync),
     root_dir: PathBuf,
     ignore_files: Vec<PathBuf>,
     options: StatusOptions,
 ) -> Result<(DirstateStatus<'dirstate>, Vec<PatternFileWarning>), StatusError>
 {
     // Force the global rayon threadpool to not exceed 16 concurrent threads.
     // This is a stop-gap measure until we figure out why using more than 16
     // threads makes `status` slower for each additional thread.
     // We use `ok()` in case the global threadpool has already been
     // instantiated in `rhg` or some other caller.
     // TODO find the underlying cause and fix it, then remove this.
     rayon::ThreadPoolBuilder::new()
         .num_threads(16.min(rayon::current_num_threads()))
         .build_global()
         .ok();
 
     let (ignore_fn, warnings, patterns_changed): (IgnoreFnType, _, _) =
         if options.list_ignored || options.list_unknown {
             let (ignore_fn, warnings, changed) = match dmap.dirstate_version {
                 DirstateVersion::V1 => {
                     let (ignore_fn, warnings) = get_ignore_function(
                         ignore_files,
                         &root_dir,
                         &mut |_source, _pattern_bytes| {},
                     )?;
                     (ignore_fn, warnings, None)
                 }
                 DirstateVersion::V2 => {
                     let mut hasher = Sha1::new();
                     let (ignore_fn, warnings) = get_ignore_function(
                         ignore_files,
                         &root_dir,
                         &mut |source, pattern_bytes| {
                             // If inside the repo, use the relative version to
                             // make it deterministic inside tests.
                             // The performance hit should be negligible.
                             let source = source
                                 .strip_prefix(&root_dir)
                                 .unwrap_or(source);
                             let source = get_bytes_from_path(source);
 
                             let mut subhasher = Sha1::new();
                             subhasher.update(pattern_bytes);
                             let patterns_hash = subhasher.finalize();
 
                             hasher.update(source);
                             hasher.update(b" ");
                             hasher.update(patterns_hash);
                             hasher.update(b"\n");
                         },
                     )?;
                     let new_hash = *hasher.finalize().as_ref();
                     let changed = new_hash != dmap.ignore_patterns_hash;
                     dmap.ignore_patterns_hash = new_hash;
                     (ignore_fn, warnings, Some(changed))
                 }
             };
             (ignore_fn, warnings, changed)
         } else {
             (Box::new(|&_| true), vec![], None)
         };
 
     let filesystem_time_at_status_start =
         filesystem_now(&root_dir).ok().map(TruncatedTimestamp::from);
 
     // If the repository is under the current directory, prefer using a
     // relative path, so the kernel needs to traverse fewer directory in every
     // call to `read_dir` or `symlink_metadata`.
     // This is effective in the common case where the current directory is the
     // repository root.
 
     // TODO: Better yet would be to use libc functions like `openat` and
     // `fstatat` to remove such repeated traversals entirely, but the standard
     // library does not provide APIs based on those.
     // Maybe with a crate like https://crates.io/crates/openat instead?
     let root_dir = if let Some(relative) = std::env::current_dir()
         .ok()
         .and_then(|cwd| root_dir.strip_prefix(cwd).ok())
     {
         relative
     } else {
         &root_dir
     };
 
     let outcome = DirstateStatus {
         filesystem_time_at_status_start,
         ..Default::default()
     };
     let common = StatusCommon {
         dmap,
         options,
         matcher,
         ignore_fn,
         outcome: Mutex::new(outcome),
         ignore_patterns_have_changed: patterns_changed,
         new_cacheable_directories: Default::default(),
         outdated_cached_directories: Default::default(),
         filesystem_time_at_status_start,
     };
     let is_at_repo_root = true;
     let hg_path = &BorrowedPath::OnDisk(HgPath::new(""));
     let has_ignored_ancestor = HasIgnoredAncestor::create(None, hg_path);
     let root_cached_mtime = None;
     // If the path we have for the repository root is a symlink, do follow it.
     // (As opposed to symlinks within the working directory which are not
     // followed, using `std::fs::symlink_metadata`.)
     common.traverse_fs_directory_and_dirstate(
         &has_ignored_ancestor,
         dmap.root.as_ref(),
         hg_path,
         &DirEntry {
             hg_path: Cow::Borrowed(HgPath::new(b"")),
-            fs_path: Cow::Borrowed(&root_dir),
+            fs_path: Cow::Borrowed(root_dir),
             symlink_metadata: None,
             file_type: FakeFileType::Directory,
         },
         root_cached_mtime,
         is_at_repo_root,
     )?;
     let mut outcome = common.outcome.into_inner().unwrap();
     let new_cacheable = common.new_cacheable_directories.into_inner().unwrap();
     let outdated = common.outdated_cached_directories.into_inner().unwrap();
 
     outcome.dirty = common.ignore_patterns_have_changed == Some(true)
         || !outdated.is_empty()
         || (!new_cacheable.is_empty()
             && dmap.dirstate_version == DirstateVersion::V2);
 
     // Remove outdated mtimes before adding new mtimes, in case a given
     // directory is both
     for path in &outdated {
         dmap.clear_cached_mtime(path)?;
     }
     for (path, mtime) in &new_cacheable {
         dmap.set_cached_mtime(path, *mtime)?;
     }
 
     Ok((outcome, warnings))
 }
 
 /// Bag of random things needed by various parts of the algorithm. Reduces the
 /// number of parameters passed to functions.
 struct StatusCommon<'a, 'tree, 'on_disk: 'tree> {
     dmap: &'tree DirstateMap<'on_disk>,
     options: StatusOptions,
     matcher: &'a (dyn Matcher + Sync),
     ignore_fn: IgnoreFnType<'a>,
     outcome: Mutex<DirstateStatus<'on_disk>>,
     /// New timestamps of directories to be used for caching their readdirs
     new_cacheable_directories:
         Mutex<Vec<(Cow<'on_disk, HgPath>, TruncatedTimestamp)>>,
     /// Used to invalidate the readdir cache of directories
     outdated_cached_directories: Mutex<Vec<Cow<'on_disk, HgPath>>>,
 
     /// Whether ignore files like `.hgignore` have changed since the previous
     /// time a `status()` call wrote their hash to the dirstate. `None` means
     /// we don’t know as this run doesn’t list either ignored or uknown files
     /// and therefore isn’t reading `.hgignore`.
     ignore_patterns_have_changed: Option<bool>,
 
     /// The current time at the start of the `status()` algorithm, as measured
     /// and possibly truncated by the filesystem.
     filesystem_time_at_status_start: Option<TruncatedTimestamp>,
 }
 
 enum Outcome {
     Modified,
     Added,
     Removed,
     Deleted,
     Clean,
     Ignored,
     Unknown,
     Unsure,
 }
 
 /// Lazy computation of whether a given path has a hgignored
 /// ancestor.
 struct HasIgnoredAncestor<'a> {
     /// `path` and `parent` constitute the inputs to the computation,
     /// `cache` stores the outcome.
     path: &'a HgPath,
     parent: Option<&'a HasIgnoredAncestor<'a>>,
     cache: OnceCell<bool>,
 }
 
 impl<'a> HasIgnoredAncestor<'a> {
     fn create(
         parent: Option<&'a HasIgnoredAncestor<'a>>,
         path: &'a HgPath,
     ) -> HasIgnoredAncestor<'a> {
         Self {
             path,
             parent,
             cache: OnceCell::new(),
         }
     }
 
     fn force<'b>(&self, ignore_fn: &IgnoreFnType<'b>) -> bool {
         match self.parent {
             None => false,
             Some(parent) => {
                 *(parent.cache.get_or_init(|| {
-                    parent.force(ignore_fn) || ignore_fn(&self.path)
+                    parent.force(ignore_fn) || ignore_fn(self.path)
                 }))
             }
         }
     }
 }
 
 impl<'a, 'tree, 'on_disk> StatusCommon<'a, 'tree, 'on_disk> {
     fn push_outcome(
         &self,
         which: Outcome,
         dirstate_node: &NodeRef<'tree, 'on_disk>,
     ) -> Result<(), DirstateV2ParseError> {
         let path = dirstate_node
             .full_path_borrowed(self.dmap.on_disk)?
             .detach_from_tree();
         let copy_source = if self.options.list_copies {
             dirstate_node
                 .copy_source_borrowed(self.dmap.on_disk)?
                 .map(|source| source.detach_from_tree())
         } else {
             None
         };
         self.push_outcome_common(which, path, copy_source);
         Ok(())
     }
 
     fn push_outcome_without_copy_source(
         &self,
         which: Outcome,
         path: &BorrowedPath<'_, 'on_disk>,
     ) {
         self.push_outcome_common(which, path.detach_from_tree(), None)
     }
 
     fn push_outcome_common(
         &self,
         which: Outcome,
         path: HgPathCow<'on_disk>,
         copy_source: Option<HgPathCow<'on_disk>>,
     ) {
         let mut outcome = self.outcome.lock().unwrap();
         let vec = match which {
             Outcome::Modified => &mut outcome.modified,
             Outcome::Added => &mut outcome.added,
             Outcome::Removed => &mut outcome.removed,
             Outcome::Deleted => &mut outcome.deleted,
             Outcome::Clean => &mut outcome.clean,
             Outcome::Ignored => &mut outcome.ignored,
             Outcome::Unknown => &mut outcome.unknown,
             Outcome::Unsure => &mut outcome.unsure,
         };
         vec.push(StatusPath { path, copy_source });
     }
 
     fn read_dir(
         &self,
         hg_path: &HgPath,
         fs_path: &Path,
         is_at_repo_root: bool,
     ) -> Result<Vec<DirEntry>, ()> {
         DirEntry::read_dir(fs_path, is_at_repo_root)
             .map_err(|error| self.io_error(error, hg_path))
     }
 
     fn io_error(&self, error: std::io::Error, hg_path: &HgPath) {
         let errno = error.raw_os_error().expect("expected real OS error");
         self.outcome
             .lock()
             .unwrap()
             .bad
             .push((hg_path.to_owned().into(), BadMatch::OsError(errno)))
     }
 
     fn check_for_outdated_directory_cache(
         &self,
         dirstate_node: &NodeRef<'tree, 'on_disk>,
     ) -> Result<bool, DirstateV2ParseError> {
         if self.ignore_patterns_have_changed == Some(true)
             && dirstate_node.cached_directory_mtime()?.is_some()
         {
             self.outdated_cached_directories.lock().unwrap().push(
                 dirstate_node
                     .full_path_borrowed(self.dmap.on_disk)?
                     .detach_from_tree(),
             );
             return Ok(true);
         }
         Ok(false)
     }
 
     /// If this returns true, we can get accurate results by only using
     /// `symlink_metadata` for child nodes that exist in the dirstate and don’t
     /// need to call `read_dir`.
     fn can_skip_fs_readdir(
         &self,
         directory_entry: &DirEntry,
         cached_directory_mtime: Option<TruncatedTimestamp>,
     ) -> bool {
         if !self.options.list_unknown && !self.options.list_ignored {
             // All states that we care about listing have corresponding
             // dirstate entries.
             // This happens for example with `hg status -mard`.
             return true;
         }
         if !self.options.list_ignored
             && self.ignore_patterns_have_changed == Some(false)
         {
             if let Some(cached_mtime) = cached_directory_mtime {
                 // The dirstate contains a cached mtime for this directory, set
                 // by a previous run of the `status` algorithm which found this
                 // directory eligible for `read_dir` caching.
                 if let Ok(meta) = directory_entry.symlink_metadata() {
                     if cached_mtime
                         .likely_equal_to_mtime_of(&meta)
                         .unwrap_or(false)
                     {
                         // The mtime of that directory has not changed
                         // since then, which means that the results of
                         // `read_dir` should also be unchanged.
                         return true;
                     }
                 }
             }
         }
         false
     }
 
     /// Returns whether all child entries of the filesystem directory have a
     /// corresponding dirstate node or are ignored.
     fn traverse_fs_directory_and_dirstate<'ancestor>(
         &self,
         has_ignored_ancestor: &'ancestor HasIgnoredAncestor<'ancestor>,
         dirstate_nodes: ChildNodesRef<'tree, 'on_disk>,
         directory_hg_path: &BorrowedPath<'tree, 'on_disk>,
         directory_entry: &DirEntry,
         cached_directory_mtime: Option<TruncatedTimestamp>,
         is_at_repo_root: bool,
     ) -> Result<bool, DirstateV2ParseError> {
         if self.can_skip_fs_readdir(directory_entry, cached_directory_mtime) {
             dirstate_nodes
                 .par_iter()
                 .map(|dirstate_node| {
                     let fs_path = &directory_entry.fs_path;
                     let fs_path = fs_path.join(get_path_from_bytes(
                         dirstate_node.base_name(self.dmap.on_disk)?.as_bytes(),
                     ));
                     match std::fs::symlink_metadata(&fs_path) {
                         Ok(fs_metadata) => {
                             let file_type =
                                 match fs_metadata.file_type().try_into() {
                                     Ok(file_type) => file_type,
                                     Err(_) => return Ok(()),
                                 };
                             let entry = DirEntry {
                                 hg_path: Cow::Borrowed(
                                     dirstate_node
-                                        .full_path(&self.dmap.on_disk)?,
+                                        .full_path(self.dmap.on_disk)?,
                                 ),
                                 fs_path: Cow::Borrowed(&fs_path),
                                 symlink_metadata: Some(fs_metadata),
                                 file_type,
                             };
                             self.traverse_fs_and_dirstate(
                                 &entry,
                                 dirstate_node,
                                 has_ignored_ancestor,
                             )
                         }
                         Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
                             self.traverse_dirstate_only(dirstate_node)
                         }
                         Err(error) => {
                             let hg_path =
                                 dirstate_node.full_path(self.dmap.on_disk)?;
-                            Ok(self.io_error(error, hg_path))
+                            self.io_error(error, hg_path);
+                            Ok(())
                         }
                     }
                 })
                 .collect::<Result<_, _>>()?;
 
             // We don’t know, so conservatively say this isn’t the case
             let children_all_have_dirstate_node_or_are_ignored = false;
 
             return Ok(children_all_have_dirstate_node_or_are_ignored);
         }
 
         let mut fs_entries = if let Ok(entries) = self.read_dir(
             directory_hg_path,
             &directory_entry.fs_path,
             is_at_repo_root,
         ) {
             entries
         } else {
             // Treat an unreadable directory (typically because of insufficient
             // permissions) like an empty directory. `self.read_dir` has
             // already called `self.io_error` so a warning will be emitted.
             Vec::new()
         };
 
         // `merge_join_by` requires both its input iterators to be sorted:
 
         let dirstate_nodes = dirstate_nodes.sorted();
         // `sort_unstable_by_key` doesn’t allow keys borrowing from the value:
         // https://github.com/rust-lang/rust/issues/34162
         fs_entries.sort_unstable_by(|e1, e2| e1.hg_path.cmp(&e2.hg_path));
 
         // Propagate here any error that would happen inside the comparison
         // callback below
         for dirstate_node in &dirstate_nodes {
             dirstate_node.base_name(self.dmap.on_disk)?;
         }
         itertools::merge_join_by(
             dirstate_nodes,
             &fs_entries,
             |dirstate_node, fs_entry| {
                 // This `unwrap` never panics because we already propagated
                 // those errors above
                 dirstate_node
                     .base_name(self.dmap.on_disk)
                     .unwrap()
                     .cmp(&fs_entry.hg_path)
             },
         )
         .par_bridge()
         .map(|pair| {
             use itertools::EitherOrBoth::*;
-            let has_dirstate_node_or_is_ignored;
-            match pair {
+            let has_dirstate_node_or_is_ignored = match pair {
                 Both(dirstate_node, fs_entry) => {
                     self.traverse_fs_and_dirstate(
-                        &fs_entry,
+                        fs_entry,
                         dirstate_node,
                         has_ignored_ancestor,
                     )?;
-                    has_dirstate_node_or_is_ignored = true
+                    true
                 }
                 Left(dirstate_node) => {
                     self.traverse_dirstate_only(dirstate_node)?;
-                    has_dirstate_node_or_is_ignored = true;
+                    true
                 }
-                Right(fs_entry) => {
-                    has_dirstate_node_or_is_ignored = self.traverse_fs_only(
-                        has_ignored_ancestor.force(&self.ignore_fn),
-                        directory_hg_path,
-                        fs_entry,
-                    )
-                }
-            }
+                Right(fs_entry) => self.traverse_fs_only(
+                    has_ignored_ancestor.force(&self.ignore_fn),
+                    directory_hg_path,
+                    fs_entry,
+                ),
+            };
             Ok(has_dirstate_node_or_is_ignored)
         })
         .try_reduce(|| true, |a, b| Ok(a && b))
     }
 
     fn traverse_fs_and_dirstate<'ancestor>(
         &self,
         fs_entry: &DirEntry,
         dirstate_node: NodeRef<'tree, 'on_disk>,
         has_ignored_ancestor: &'ancestor HasIgnoredAncestor<'ancestor>,
     ) -> Result<(), DirstateV2ParseError> {
         let outdated_dircache =
             self.check_for_outdated_directory_cache(&dirstate_node)?;
         let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;
         let file_or_symlink = fs_entry.is_file() || fs_entry.is_symlink();
         if !file_or_symlink {
             // If we previously had a file here, it was removed (with
             // `hg rm` or similar) or deleted before it could be
             // replaced by a directory or something else.
             self.mark_removed_or_deleted_if_file(&dirstate_node)?;
         }
         if fs_entry.is_dir() {
             if self.options.collect_traversed_dirs {
                 self.outcome
                     .lock()
                     .unwrap()
                     .traversed
                     .push(hg_path.detach_from_tree())
             }
             let is_ignored = HasIgnoredAncestor::create(
-                Some(&has_ignored_ancestor),
+                Some(has_ignored_ancestor),
                 hg_path,
             );
             let is_at_repo_root = false;
             let children_all_have_dirstate_node_or_are_ignored = self
                 .traverse_fs_directory_and_dirstate(
                     &is_ignored,
                     dirstate_node.children(self.dmap.on_disk)?,
                     hg_path,
                     fs_entry,
                     dirstate_node.cached_directory_mtime()?,
                     is_at_repo_root,
                 )?;
             self.maybe_save_directory_mtime(
                 children_all_have_dirstate_node_or_are_ignored,
                 fs_entry,
                 dirstate_node,
                 outdated_dircache,
             )?
         } else {
-            if file_or_symlink && self.matcher.matches(&hg_path) {
+            if file_or_symlink && self.matcher.matches(hg_path) {
                 if let Some(entry) = dirstate_node.entry()? {
                     if !entry.any_tracked() {
                         // Forward-compat if we start tracking unknown/ignored
                         // files for caching reasons
                         self.mark_unknown_or_ignored(
                             has_ignored_ancestor.force(&self.ignore_fn),
-                            &hg_path,
+                            hg_path,
                         );
                     }
                     if entry.added() {
                         self.push_outcome(Outcome::Added, &dirstate_node)?;
                     } else if entry.removed() {
                         self.push_outcome(Outcome::Removed, &dirstate_node)?;
                     } else if entry.modified() {
                         self.push_outcome(Outcome::Modified, &dirstate_node)?;
                     } else {
                         self.handle_normal_file(&dirstate_node, fs_entry)?;
                     }
                 } else {
                     // `node.entry.is_none()` indicates a "directory"
                     // node, but the filesystem has a file
                     self.mark_unknown_or_ignored(
                         has_ignored_ancestor.force(&self.ignore_fn),
                         hg_path,
                     );
                 }
             }
 
             for child_node in dirstate_node.children(self.dmap.on_disk)?.iter()
             {
                 self.traverse_dirstate_only(child_node)?
             }
         }
         Ok(())
     }
 
     /// Save directory mtime if applicable.
     ///
     /// `outdated_directory_cache` is `true` if we've just invalidated the
     /// cache for this directory in `check_for_outdated_directory_cache`,
     /// which forces the update.
     fn maybe_save_directory_mtime(
         &self,
         children_all_have_dirstate_node_or_are_ignored: bool,
         directory_entry: &DirEntry,
         dirstate_node: NodeRef<'tree, 'on_disk>,
         outdated_directory_cache: bool,
     ) -> Result<(), DirstateV2ParseError> {
         if !children_all_have_dirstate_node_or_are_ignored {
             return Ok(());
         }
         // All filesystem directory entries from `read_dir` have a
         // corresponding node in the dirstate, so we can reconstitute the
         // names of those entries without calling `read_dir` again.
 
         // TODO: use let-else here and below when available:
         // https://github.com/rust-lang/rust/issues/87335
         let status_start = if let Some(status_start) =
             &self.filesystem_time_at_status_start
         {
             status_start
         } else {
             return Ok(());
         };
 
         // Although the Rust standard library’s `SystemTime` type
         // has nanosecond precision, the times reported for a
         // directory’s (or file’s) modified time may have lower
         // resolution based on the filesystem (for example ext3
         // only stores integer seconds), kernel (see
         // https://stackoverflow.com/a/14393315/1162888), etc.
         let metadata = match directory_entry.symlink_metadata() {
             Ok(meta) => meta,
             Err(_) => return Ok(()),
         };
-        let directory_mtime = if let Ok(option) =
-            TruncatedTimestamp::for_reliable_mtime_of(&metadata, status_start)
-        {
-            if let Some(directory_mtime) = option {
-                directory_mtime
-            } else {
+
+        let directory_mtime = match TruncatedTimestamp::for_reliable_mtime_of(
+            &metadata,
+            status_start,
+        ) {
+            Ok(Some(directory_mtime)) => directory_mtime,
+            Ok(None) => {
                 // The directory was modified too recently,
                 // don’t cache its `read_dir` results.
                 //
                 // 1. A change to this directory (direct child was
                 //    added or removed) cause its mtime to be set
                 //    (possibly truncated) to `directory_mtime`
                 // 2. This `status` algorithm calls `read_dir`
                 // 3. An other change is made to the same directory is
                 //    made so that calling `read_dir` agin would give
                 //    different results, but soon enough after 1. that
                 //    the mtime stays the same
                 //
                 // On a system where the time resolution poor, this
                 // scenario is not unlikely if all three steps are caused
                 // by the same script.
                 return Ok(());
             }
-        } else {
-            // OS/libc does not support mtime?
-            return Ok(());
+            Err(_) => {
+                // OS/libc does not support mtime?
+                return Ok(());
+            }
         };
         // We’ve observed (through `status_start`) that time has
         // “progressed” since `directory_mtime`, so any further
         // change to this directory is extremely likely to cause a
         // different mtime.
         //
         // Having the same mtime again is not entirely impossible
         // since the system clock is not monotonous. It could jump
         // backward to some point before `directory_mtime`, then a
         // directory change could potentially happen during exactly
         // the wrong tick.
         //
         // We deem this scenario (unlike the previous one) to be
         // unlikely enough in practice.
 
         let is_up_to_date = if let Some(cached) =
             dirstate_node.cached_directory_mtime()?
         {
             !outdated_directory_cache && cached.likely_equal(directory_mtime)
         } else {
             false
         };
         if !is_up_to_date {
             let hg_path = dirstate_node
                 .full_path_borrowed(self.dmap.on_disk)?
                 .detach_from_tree();
             self.new_cacheable_directories
                 .lock()
                 .unwrap()
                 .push((hg_path, directory_mtime))
         }
         Ok(())
     }
 
     /// A file that is clean in the dirstate was found in the filesystem
     fn handle_normal_file(
         &self,
         dirstate_node: &NodeRef<'tree, 'on_disk>,
         fs_entry: &DirEntry,
     ) -> Result<(), DirstateV2ParseError> {
         // Keep the low 31 bits
         fn truncate_u64(value: u64) -> i32 {
             (value & 0x7FFF_FFFF) as i32
         }
 
         let fs_metadata = match fs_entry.symlink_metadata() {
             Ok(meta) => meta,
             Err(_) => return Ok(()),
         };
 
         let entry = dirstate_node
             .entry()?
             .expect("handle_normal_file called with entry-less node");
         let mode_changed =
             || self.options.check_exec && entry.mode_changed(&fs_metadata);
         let size = entry.size();
         let size_changed = size != truncate_u64(fs_metadata.len());
         if size >= 0 && size_changed && fs_metadata.file_type().is_symlink() {
             // issue6456: Size returned may be longer due to encryption
             // on EXT-4 fscrypt. TODO maybe only do it on EXT4?
             self.push_outcome(Outcome::Unsure, dirstate_node)?
         } else if dirstate_node.has_copy_source()
             || entry.is_from_other_parent()
             || (size >= 0 && (size_changed || mode_changed()))
         {
             self.push_outcome(Outcome::Modified, dirstate_node)?
         } else {
-            let mtime_looks_clean;
-            if let Some(dirstate_mtime) = entry.truncated_mtime() {
+            let mtime_looks_clean = if let Some(dirstate_mtime) =
+                entry.truncated_mtime()
+            {
                 let fs_mtime = TruncatedTimestamp::for_mtime_of(&fs_metadata)
                     .expect("OS/libc does not support mtime?");
                 // There might be a change in the future if for example the
                 // internal clock become off while process run, but this is a
                 // case where the issues the user would face
                 // would be a lot worse and there is nothing we
                 // can really do.
-                mtime_looks_clean = fs_mtime.likely_equal(dirstate_mtime)
+                fs_mtime.likely_equal(dirstate_mtime)
             } else {
                 // No mtime in the dirstate entry
-                mtime_looks_clean = false
+                false
             };
             if !mtime_looks_clean {
                 self.push_outcome(Outcome::Unsure, dirstate_node)?
             } else if self.options.list_clean {
                 self.push_outcome(Outcome::Clean, dirstate_node)?
             }
         }
         Ok(())
     }
 
     /// A node in the dirstate tree has no corresponding filesystem entry
     fn traverse_dirstate_only(
         &self,
         dirstate_node: NodeRef<'tree, 'on_disk>,
     ) -> Result<(), DirstateV2ParseError> {
         self.check_for_outdated_directory_cache(&dirstate_node)?;
         self.mark_removed_or_deleted_if_file(&dirstate_node)?;
         dirstate_node
             .children(self.dmap.on_disk)?
             .par_iter()
             .map(|child_node| self.traverse_dirstate_only(child_node))
             .collect()
     }
 
     /// A node in the dirstate tree has no corresponding *file* on the
     /// filesystem
     ///
     /// Does nothing on a "directory" node
     fn mark_removed_or_deleted_if_file(
         &self,
         dirstate_node: &NodeRef<'tree, 'on_disk>,
     ) -> Result<(), DirstateV2ParseError> {
         if let Some(entry) = dirstate_node.entry()? {
             if !entry.any_tracked() {
                 // Future-compat for when we start storing ignored and unknown
                 // files for caching reasons
                 return Ok(());
             }
             let path = dirstate_node.full_path(self.dmap.on_disk)?;
             if self.matcher.matches(path) {
                 if entry.removed() {
                     self.push_outcome(Outcome::Removed, dirstate_node)?
                 } else {
-                    self.push_outcome(Outcome::Deleted, &dirstate_node)?
+                    self.push_outcome(Outcome::Deleted, dirstate_node)?
                 }
             }
         }
         Ok(())
     }
 
     /// Something in the filesystem has no corresponding dirstate node
     ///
     /// Returns whether that path is ignored
     fn traverse_fs_only(
         &self,
         has_ignored_ancestor: bool,
         directory_hg_path: &HgPath,
         fs_entry: &DirEntry,
     ) -> bool {
         let hg_path = directory_hg_path.join(&fs_entry.hg_path);
         let file_or_symlink = fs_entry.is_file() || fs_entry.is_symlink();
         if fs_entry.is_dir() {
             let is_ignored =
                 has_ignored_ancestor || (self.ignore_fn)(&hg_path);
             let traverse_children = if is_ignored {
                 // Descendants of an ignored directory are all ignored
                 self.options.list_ignored
             } else {
                 // Descendants of an unknown directory may be either unknown or
                 // ignored
                 self.options.list_unknown || self.options.list_ignored
             };
             if traverse_children {
                 let is_at_repo_root = false;
                 if let Ok(children_fs_entries) =
                     self.read_dir(&hg_path, &fs_entry.fs_path, is_at_repo_root)
                 {
                     children_fs_entries.par_iter().for_each(|child_fs_entry| {
                         self.traverse_fs_only(
                             is_ignored,
                             &hg_path,
                             child_fs_entry,
                         );
                     })
                 }
                 if self.options.collect_traversed_dirs {
                     self.outcome.lock().unwrap().traversed.push(hg_path.into())
                 }
             }
             is_ignored
+        } else if file_or_symlink {
+            if self.matcher.matches(&hg_path) {
+                self.mark_unknown_or_ignored(
+                    has_ignored_ancestor,
+                    &BorrowedPath::InMemory(&hg_path),
+                )
+            } else {
+                // We haven’t computed whether this path is ignored. It
+                // might not be, and a future run of status might have a
+                // different matcher that matches it. So treat it as not
+                // ignored. That is, inhibit readdir caching of the parent
+                // directory.
+                false
+            }
         } else {
-            if file_or_symlink {
-                if self.matcher.matches(&hg_path) {
-                    self.mark_unknown_or_ignored(
-                        has_ignored_ancestor,
-                        &BorrowedPath::InMemory(&hg_path),
-                    )
-                } else {
-                    // We haven’t computed whether this path is ignored. It
-                    // might not be, and a future run of status might have a
-                    // different matcher that matches it. So treat it as not
-                    // ignored. That is, inhibit readdir caching of the parent
-                    // directory.
-                    false
-                }
-            } else {
-                // This is neither a directory, a plain file, or a symlink.
-                // Treat it like an ignored file.
-                true
-            }
+            // This is neither a directory, a plain file, or a symlink.
+            // Treat it like an ignored file.
+            true
         }
     }
 
     /// Returns whether that path is ignored
     fn mark_unknown_or_ignored(
         &self,
         has_ignored_ancestor: bool,
         hg_path: &BorrowedPath<'_, 'on_disk>,
     ) -> bool {
-        let is_ignored = has_ignored_ancestor || (self.ignore_fn)(&hg_path);
+        let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path);
         if is_ignored {
             if self.options.list_ignored {
                 self.push_outcome_without_copy_source(
                     Outcome::Ignored,
                     hg_path,
                 )
             }
-        } else {
-            if self.options.list_unknown {
-                self.push_outcome_without_copy_source(
-                    Outcome::Unknown,
-                    hg_path,
-                )
-            }
+        } else if self.options.list_unknown {
+            self.push_outcome_without_copy_source(Outcome::Unknown, hg_path)
         }
         is_ignored
     }
 }
 
 /// Since [`std::fs::FileType`] cannot be built directly, we emulate what we
 /// care about.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum FakeFileType {
     File,
     Directory,
     Symlink,
 }
 
 impl TryFrom<std::fs::FileType> for FakeFileType {
     type Error = ();
 
     fn try_from(f: std::fs::FileType) -> Result<Self, Self::Error> {
         if f.is_dir() {
             Ok(Self::Directory)
         } else if f.is_file() {
             Ok(Self::File)
         } else if f.is_symlink() {
             Ok(Self::Symlink)
         } else {
             // Things like FIFO etc.
             Err(())
         }
     }
 }
 
 struct DirEntry<'a> {
     /// Path as stored in the dirstate, or just the filename for optimization.
     hg_path: HgPathCow<'a>,
     /// Filesystem path
     fs_path: Cow<'a, Path>,
     /// Lazily computed
     symlink_metadata: Option<std::fs::Metadata>,
     /// Already computed for ergonomics.
     file_type: FakeFileType,
 }
 
 impl<'a> DirEntry<'a> {
     /// Returns **unsorted** entries in the given directory, with name,
     /// metadata and file type.
     ///
     /// If a `.hg` sub-directory is encountered:
     ///
     /// * At the repository root, ignore that sub-directory
     /// * Elsewhere, we’re listing the content of a sub-repo. Return an empty
     ///   list instead.
     fn read_dir(path: &Path, is_at_repo_root: bool) -> io::Result<Vec<Self>> {
         // `read_dir` returns a "not found" error for the empty path
         let at_cwd = path == Path::new("");
         let read_dir_path = if at_cwd { Path::new(".") } else { path };
         let mut results = Vec::new();
         for entry in read_dir_path.read_dir()? {
             let entry = entry?;
             let file_type = match entry.file_type() {
                 Ok(v) => v,
                 Err(e) => {
                     // race with file deletion?
                     if e.kind() == std::io::ErrorKind::NotFound {
                         continue;
                     } else {
                         return Err(e);
                     }
                 }
             };
             let file_name = entry.file_name();
             // FIXME don't do this when cached
             if file_name == ".hg" {
                 if is_at_repo_root {
                     // Skip the repo’s own .hg (might be a symlink)
                     continue;
                 } else if file_type.is_dir() {
                     // A .hg sub-directory at another location means a subrepo,
                     // skip it entirely.
                     return Ok(Vec::new());
                 }
             }
             let full_path = if at_cwd {
                 file_name.clone().into()
             } else {
                 entry.path()
             };
             let filename =
                 Cow::Owned(get_bytes_from_os_string(file_name).into());
             let file_type = match FakeFileType::try_from(file_type) {
                 Ok(file_type) => file_type,
                 Err(_) => continue,
             };
             results.push(DirEntry {
                 hg_path: filename,
                 fs_path: Cow::Owned(full_path.to_path_buf()),
                 symlink_metadata: None,
                 file_type,
             })
         }
         Ok(results)
     }
 
     fn symlink_metadata(&self) -> Result<std::fs::Metadata, std::io::Error> {
         match &self.symlink_metadata {
             Some(meta) => Ok(meta.clone()),
             None => std::fs::symlink_metadata(&self.fs_path),
         }
     }
 
     fn is_dir(&self) -> bool {
         self.file_type == FakeFileType::Directory
     }
 
     fn is_file(&self) -> bool {
         self.file_type == FakeFileType::File
     }
 
     fn is_symlink(&self) -> bool {
         self.file_type == FakeFileType::Symlink
     }
 }
 
 /// Return the `mtime` of a temporary file newly-created in the `.hg` directory
 /// of the give repository.
 ///
 /// This is similar to `SystemTime::now()`, with the result truncated to the
 /// same time resolution as other files’ modification times. Using `.hg`
 /// instead of the system’s default temporary directory (such as `/tmp`) makes
 /// it more likely the temporary file is in the same disk partition as contents
 /// of the working directory, which can matter since different filesystems may
 /// store timestamps with different resolutions.
 ///
 /// This may fail, typically if we lack write permissions. In that case we
 /// should continue the `status()` algoritm anyway and consider the current
 /// date/time to be unknown.
 fn filesystem_now(repo_root: &Path) -> Result<SystemTime, io::Error> {
     tempfile::tempfile_in(repo_root.join(".hg"))?
         .metadata()?
         .modified()
 }

rust/hg-core/src/discovery.rs

@@ -1,695 +1,695 b''
 // discovery.rs
 //
 // Copyright 2019 Georges Racinet <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Discovery operations
 //!
 //! This is a Rust counterpart to the `partialdiscovery` class of
 //! `mercurial.setdiscovery`
 
 use super::{Graph, GraphError, Revision, NULL_REVISION};
 use crate::{ancestors::MissingAncestors, dagops, FastHashMap};
 use rand::seq::SliceRandom;
 use rand::{thread_rng, RngCore, SeedableRng};
 use std::cmp::{max, min};
 use std::collections::{HashSet, VecDeque};
 
 type Rng = rand_pcg::Pcg32;
 type Seed = [u8; 16];
 
 pub struct PartialDiscovery<G: Graph + Clone> {
     target_heads: Option<Vec<Revision>>,
     graph: G, // plays the role of self._repo
     common: MissingAncestors<G>,
     undecided: Option<HashSet<Revision>>,
     children_cache: Option<FastHashMap<Revision, Vec<Revision>>>,
     missing: HashSet<Revision>,
     rng: Rng,
     respect_size: bool,
     randomize: bool,
 }
 
 pub struct DiscoveryStats {
     pub undecided: Option<usize>,
 }
 
 /// Update an existing sample to match the expected size
 ///
 /// The sample is updated with revisions exponentially distant from each
 /// element of `heads`.
 ///
 /// If a target size is specified, the sampling will stop once this size is
 /// reached. Otherwise sampling will happen until roots of the <revs> set are
 /// reached.
 ///
 /// - `revs`: set of revs we want to discover (if None, `assume` the whole dag
 ///   represented by `parentfn`
 /// - `heads`: set of DAG head revs
 /// - `sample`: a sample to update
 /// - `parentfn`: a callable to resolve parents for a revision
 /// - `quicksamplesize`: optional target size of the sample
 fn update_sample<I>(
     revs: Option<&HashSet<Revision>>,
     heads: impl IntoIterator<Item = Revision>,
     sample: &mut HashSet<Revision>,
     parentsfn: impl Fn(Revision) -> Result<I, GraphError>,
     quicksamplesize: Option<usize>,
 ) -> Result<(), GraphError>
 where
     I: Iterator<Item = Revision>,
 {
     let mut distances: FastHashMap<Revision, u32> = FastHashMap::default();
     let mut visit: VecDeque<Revision> = heads.into_iter().collect();
     let mut factor: u32 = 1;
     let mut seen: HashSet<Revision> = HashSet::new();
     while let Some(current) = visit.pop_front() {
         if !seen.insert(current) {
             continue;
         }
 
         let d = *distances.entry(current).or_insert(1);
         if d > factor {
             factor *= 2;
         }
         if d == factor {
             sample.insert(current);
             if let Some(sz) = quicksamplesize {
                 if sample.len() >= sz {
                     return Ok(());
                 }
             }
         }
         for p in parentsfn(current)? {
             if let Some(revs) = revs {
                 if !revs.contains(&p) {
                     continue;
                 }
             }
             distances.entry(p).or_insert(d + 1);
             visit.push_back(p);
         }
     }
     Ok(())
 }
 
 struct ParentsIterator {
     parents: [Revision; 2],
     cur: usize,
 }
 
 impl ParentsIterator {
     fn graph_parents(
         graph: &impl Graph,
         r: Revision,
     ) -> Result<ParentsIterator, GraphError> {
         Ok(ParentsIterator {
             parents: graph.parents(r)?,
             cur: 0,
         })
     }
 }
 
 impl Iterator for ParentsIterator {
     type Item = Revision;
 
     fn next(&mut self) -> Option<Revision> {
         if self.cur > 1 {
             return None;
         }
         let rev = self.parents[self.cur];
         self.cur += 1;
         if rev == NULL_REVISION {
             return self.next();
         }
         Some(rev)
     }
 }
 
 impl<G: Graph + Clone> PartialDiscovery<G> {
     /// Create a PartialDiscovery object, with the intent
     /// of comparing our `::<target_heads>` revset to the contents of another
     /// repo.
     ///
     /// For now `target_heads` is passed as a vector, and will be used
     /// at the first call to `ensure_undecided()`.
     ///
     /// If we want to make the signature more flexible,
     /// we'll have to make it a type argument of `PartialDiscovery` or a trait
     /// object since we'll keep it in the meanwhile
     ///
     /// The `respect_size` boolean controls how the sampling methods
     /// will interpret the size argument requested by the caller. If it's
     /// `false`, they are allowed to produce a sample whose size is more
     /// appropriate to the situation (typically bigger).
     ///
     /// The `randomize` boolean affects sampling, and specifically how
     /// limiting or last-minute expanding is been done:
     ///
     /// If `true`, both will perform random picking from `self.undecided`.
     /// This is currently the best for actual discoveries.
     ///
     /// If `false`, a reproductible picking strategy is performed. This is
     /// useful for integration tests.
     pub fn new(
         graph: G,
         target_heads: Vec<Revision>,
         respect_size: bool,
         randomize: bool,
     ) -> Self {
         let mut seed = [0; 16];
         if randomize {
             thread_rng().fill_bytes(&mut seed);
         }
         Self::new_with_seed(graph, target_heads, seed, respect_size, randomize)
     }
 
     pub fn new_with_seed(
         graph: G,
         target_heads: Vec<Revision>,
         seed: Seed,
         respect_size: bool,
         randomize: bool,
     ) -> Self {
         PartialDiscovery {
             undecided: None,
             children_cache: None,
             target_heads: Some(target_heads),
             graph: graph.clone(),
             common: MissingAncestors::new(graph, vec![]),
             missing: HashSet::new(),
             rng: Rng::from_seed(seed),
             respect_size,
             randomize,
         }
     }
 
     /// Extract at most `size` random elements from sample and return them
     /// as a vector
     fn limit_sample(
         &mut self,
         mut sample: Vec<Revision>,
         size: usize,
     ) -> Vec<Revision> {
         if !self.randomize {
-            sample.sort();
+            sample.sort_unstable();
             sample.truncate(size);
             return sample;
         }
         let sample_len = sample.len();
         if sample_len <= size {
             return sample;
         }
         let rng = &mut self.rng;
         let dropped_size = sample_len - size;
         let limited_slice = if size < dropped_size {
             sample.partial_shuffle(rng, size).0
         } else {
             sample.partial_shuffle(rng, dropped_size).1
         };
         limited_slice.to_owned()
     }
 
     /// Register revisions known as being common
     pub fn add_common_revisions(
         &mut self,
         common: impl IntoIterator<Item = Revision>,
     ) -> Result<(), GraphError> {
         let before_len = self.common.get_bases().len();
         self.common.add_bases(common);
         if self.common.get_bases().len() == before_len {
             return Ok(());
         }
         if let Some(ref mut undecided) = self.undecided {
             self.common.remove_ancestors_from(undecided)?;
         }
         Ok(())
     }
 
     /// Register revisions known as being missing
     ///
     /// # Performance note
     ///
     /// Except in the most trivial case, the first call of this method has
     /// the side effect of computing `self.undecided` set for the first time,
     /// and the related caches it might need for efficiency of its internal
     /// computation. This is typically faster if more information is
     /// available in `self.common`. Therefore, for good performance, the
     /// caller should avoid calling this too early.
     pub fn add_missing_revisions(
         &mut self,
         missing: impl IntoIterator<Item = Revision>,
     ) -> Result<(), GraphError> {
         let mut tovisit: VecDeque<Revision> = missing.into_iter().collect();
         if tovisit.is_empty() {
             return Ok(());
         }
         self.ensure_children_cache()?;
         self.ensure_undecided()?; // for safety of possible future refactors
         let children = self.children_cache.as_ref().unwrap();
         let mut seen: HashSet<Revision> = HashSet::new();
         let undecided_mut = self.undecided.as_mut().unwrap();
         while let Some(rev) = tovisit.pop_front() {
             if !self.missing.insert(rev) {
                 // either it's known to be missing from a previous
                 // invocation, and there's no need to iterate on its
                 // children (we now they are all missing)
                 // or it's from a previous iteration of this loop
                 // and its children have already been queued
                 continue;
             }
             undecided_mut.remove(&rev);
             match children.get(&rev) {
                 None => {
                     continue;
                 }
                 Some(this_children) => {
                     for child in this_children.iter().cloned() {
                         if seen.insert(child) {
                             tovisit.push_back(child);
                         }
                     }
                 }
             }
         }
         Ok(())
     }
 
     /// Do we have any information about the peer?
     pub fn has_info(&self) -> bool {
         self.common.has_bases()
     }
 
     /// Did we acquire full knowledge of our Revisions that the peer has?
     pub fn is_complete(&self) -> bool {
         self.undecided.as_ref().map_or(false, HashSet::is_empty)
     }
 
     /// Return the heads of the currently known common set of revisions.
     ///
     /// If the discovery process is not complete (see `is_complete()`), the
     /// caller must be aware that this is an intermediate state.
     ///
     /// On the other hand, if it is complete, then this is currently
     /// the only way to retrieve the end results of the discovery process.
     ///
     /// We may introduce in the future an `into_common_heads` call that
     /// would be more appropriate for normal Rust callers, dropping `self`
     /// if it is complete.
     pub fn common_heads(&self) -> Result<HashSet<Revision>, GraphError> {
         self.common.bases_heads()
     }
 
     /// Force first computation of `self.undecided`
     ///
     /// After this, `self.undecided.as_ref()` and `.as_mut()` can be
     /// unwrapped to get workable immutable or mutable references without
     /// any panic.
     ///
     /// This is an imperative call instead of an access with added lazyness
     /// to reduce easily the scope of mutable borrow for the caller,
     /// compared to undecided(&'a mut self) -> &'a… that would keep it
     /// as long as the resulting immutable one.
     fn ensure_undecided(&mut self) -> Result<(), GraphError> {
         if self.undecided.is_some() {
             return Ok(());
         }
         let tgt = self.target_heads.take().unwrap();
         self.undecided =
             Some(self.common.missing_ancestors(tgt)?.into_iter().collect());
         Ok(())
     }
 
     fn ensure_children_cache(&mut self) -> Result<(), GraphError> {
         if self.children_cache.is_some() {
             return Ok(());
         }
         self.ensure_undecided()?;
 
         let mut children: FastHashMap<Revision, Vec<Revision>> =
             FastHashMap::default();
         for &rev in self.undecided.as_ref().unwrap() {
             for p in ParentsIterator::graph_parents(&self.graph, rev)? {
                 children.entry(p).or_insert_with(Vec::new).push(rev);
             }
         }
         self.children_cache = Some(children);
         Ok(())
     }
 
     /// Provide statistics about the current state of the discovery process
     pub fn stats(&self) -> DiscoveryStats {
         DiscoveryStats {
             undecided: self.undecided.as_ref().map(HashSet::len),
         }
     }
 
     pub fn take_quick_sample(
         &mut self,
         headrevs: impl IntoIterator<Item = Revision>,
         size: usize,
     ) -> Result<Vec<Revision>, GraphError> {
         self.ensure_undecided()?;
         let mut sample = {
             let undecided = self.undecided.as_ref().unwrap();
             if undecided.len() <= size {
                 return Ok(undecided.iter().cloned().collect());
             }
             dagops::heads(&self.graph, undecided.iter())?
         };
         if sample.len() >= size {
             return Ok(self.limit_sample(sample.into_iter().collect(), size));
         }
         update_sample(
             None,
             headrevs,
             &mut sample,
             |r| ParentsIterator::graph_parents(&self.graph, r),
             Some(size),
         )?;
         Ok(sample.into_iter().collect())
     }
 
     /// Extract a sample from `self.undecided`, going from its heads and roots.
     ///
     /// The `size` parameter is used to avoid useless computations if
     /// it turns out to be bigger than the whole set of undecided Revisions.
     ///
     /// The sample is taken by using `update_sample` from the heads, then
     /// from the roots, working on the reverse DAG,
     /// expressed by `self.children_cache`.
     ///
     /// No effort is being made to complete or limit the sample to `size`
     /// but this method returns another interesting size that it derives
     /// from its knowledge of the structure of the various sets, leaving
     /// to the caller the decision to use it or not.
     fn bidirectional_sample(
         &mut self,
         size: usize,
     ) -> Result<(HashSet<Revision>, usize), GraphError> {
         self.ensure_undecided()?;
         {
             // we don't want to compute children_cache before this
             // but doing it after extracting self.undecided takes a mutable
             // ref to self while a shareable one is still active.
             let undecided = self.undecided.as_ref().unwrap();
             if undecided.len() <= size {
                 return Ok((undecided.clone(), size));
             }
         }
 
         self.ensure_children_cache()?;
         let revs = self.undecided.as_ref().unwrap();
         let mut sample: HashSet<Revision> = revs.clone();
 
         // it's possible that leveraging the children cache would be more
         // efficient here
         dagops::retain_heads(&self.graph, &mut sample)?;
         let revsheads = sample.clone(); // was again heads(revs) in python
 
         // update from heads
         update_sample(
             Some(revs),
             revsheads.iter().cloned(),
             &mut sample,
             |r| ParentsIterator::graph_parents(&self.graph, r),
             None,
         )?;
 
         // update from roots
         let revroots: HashSet<Revision> =
             dagops::roots(&self.graph, revs)?.into_iter().collect();
         let prescribed_size = max(size, min(revroots.len(), revsheads.len()));
 
         let children = self.children_cache.as_ref().unwrap();
         let empty_vec: Vec<Revision> = Vec::new();
         update_sample(
             Some(revs),
             revroots,
             &mut sample,
             |r| Ok(children.get(&r).unwrap_or(&empty_vec).iter().cloned()),
             None,
         )?;
         Ok((sample, prescribed_size))
     }
 
     /// Fill up sample up to the wished size with random undecided Revisions.
     ///
     /// This is intended to be used as a last resort completion if the
     /// regular sampling algorithm returns too few elements.
     fn random_complete_sample(
         &mut self,
         sample: &mut Vec<Revision>,
         size: usize,
     ) {
         let sample_len = sample.len();
         if size <= sample_len {
             return;
         }
         let take_from: Vec<Revision> = self
             .undecided
             .as_ref()
             .unwrap()
             .iter()
             .filter(|&r| !sample.contains(r))
             .cloned()
             .collect();
         sample.extend(self.limit_sample(take_from, size - sample_len));
     }
 
     pub fn take_full_sample(
         &mut self,
         size: usize,
     ) -> Result<Vec<Revision>, GraphError> {
         let (sample_set, prescribed_size) = self.bidirectional_sample(size)?;
         let size = if self.respect_size {
             size
         } else {
             prescribed_size
         };
         let mut sample =
             self.limit_sample(sample_set.into_iter().collect(), size);
         self.random_complete_sample(&mut sample, size);
         Ok(sample)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::testing::SampleGraph;
 
     /// A PartialDiscovery as for pushing all the heads of `SampleGraph`
     ///
     /// To avoid actual randomness in these tests, we give it a fixed
     /// random seed, but by default we'll test the random version.
     fn full_disco() -> PartialDiscovery<SampleGraph> {
         PartialDiscovery::new_with_seed(
             SampleGraph,
             vec![10, 11, 12, 13],
             [0; 16],
             true,
             true,
         )
     }
 
     /// A PartialDiscovery as for pushing the 12 head of `SampleGraph`
     ///
     /// To avoid actual randomness in tests, we give it a fixed random seed.
     fn disco12() -> PartialDiscovery<SampleGraph> {
         PartialDiscovery::new_with_seed(
             SampleGraph,
             vec![12],
             [0; 16],
             true,
             true,
         )
     }
 
     fn sorted_undecided(
         disco: &PartialDiscovery<SampleGraph>,
     ) -> Vec<Revision> {
         let mut as_vec: Vec<Revision> =
             disco.undecided.as_ref().unwrap().iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         as_vec
     }
 
     fn sorted_missing(disco: &PartialDiscovery<SampleGraph>) -> Vec<Revision> {
         let mut as_vec: Vec<Revision> =
             disco.missing.iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         as_vec
     }
 
     fn sorted_common_heads(
         disco: &PartialDiscovery<SampleGraph>,
     ) -> Result<Vec<Revision>, GraphError> {
         let mut as_vec: Vec<Revision> =
             disco.common_heads()?.iter().cloned().collect();
-        as_vec.sort();
+        as_vec.sort_unstable();
         Ok(as_vec)
     }
 
     #[test]
     fn test_add_common_get_undecided() -> Result<(), GraphError> {
         let mut disco = full_disco();
         assert_eq!(disco.undecided, None);
         assert!(!disco.has_info());
         assert_eq!(disco.stats().undecided, None);
 
         disco.add_common_revisions(vec![11, 12])?;
         assert!(disco.has_info());
         assert!(!disco.is_complete());
         assert!(disco.missing.is_empty());
 
         // add_common_revisions did not trigger a premature computation
         // of `undecided`, let's check that and ask for them
         assert_eq!(disco.undecided, None);
         disco.ensure_undecided()?;
         assert_eq!(sorted_undecided(&disco), vec![5, 8, 10, 13]);
         assert_eq!(disco.stats().undecided, Some(4));
         Ok(())
     }
 
     /// in this test, we pretend that our peer misses exactly (8+10)::
     /// and we're comparing all our repo to it (as in a bare push)
     #[test]
     fn test_discovery() -> Result<(), GraphError> {
         let mut disco = full_disco();
         disco.add_common_revisions(vec![11, 12])?;
         disco.add_missing_revisions(vec![8, 10])?;
         assert_eq!(sorted_undecided(&disco), vec![5]);
         assert_eq!(sorted_missing(&disco), vec![8, 10, 13]);
         assert!(!disco.is_complete());
 
         disco.add_common_revisions(vec![5])?;
         assert_eq!(sorted_undecided(&disco), vec![]);
         assert_eq!(sorted_missing(&disco), vec![8, 10, 13]);
         assert!(disco.is_complete());
         assert_eq!(sorted_common_heads(&disco)?, vec![5, 11, 12]);
         Ok(())
     }
 
     #[test]
     fn test_add_missing_early_continue() -> Result<(), GraphError> {
         eprintln!("test_add_missing_early_stop");
         let mut disco = full_disco();
         disco.add_common_revisions(vec![13, 3, 4])?;
         disco.ensure_children_cache()?;
         // 12 is grand-child of 6 through 9
         // passing them in this order maximizes the chances of the
         // early continue to do the wrong thing
         disco.add_missing_revisions(vec![6, 9, 12])?;
         assert_eq!(sorted_undecided(&disco), vec![5, 7, 10, 11]);
         assert_eq!(sorted_missing(&disco), vec![6, 9, 12]);
         assert!(!disco.is_complete());
         Ok(())
     }
 
     #[test]
     fn test_limit_sample_no_need_to() {
         let sample = vec![1, 2, 3, 4];
         assert_eq!(full_disco().limit_sample(sample, 10), vec![1, 2, 3, 4]);
     }
 
     #[test]
     fn test_limit_sample_less_than_half() {
         assert_eq!(full_disco().limit_sample((1..6).collect(), 2), vec![2, 5]);
     }
 
     #[test]
     fn test_limit_sample_more_than_half() {
         assert_eq!(full_disco().limit_sample((1..4).collect(), 2), vec![1, 2]);
     }
 
     #[test]
     fn test_limit_sample_no_random() {
         let mut disco = full_disco();
         disco.randomize = false;
         assert_eq!(
             disco.limit_sample(vec![1, 8, 13, 5, 7, 3], 4),
             vec![1, 3, 5, 7]
         );
     }
 
     #[test]
     fn test_quick_sample_enough_undecided_heads() -> Result<(), GraphError> {
         let mut disco = full_disco();
         disco.undecided = Some((1..=13).collect());
 
         let mut sample_vec = disco.take_quick_sample(vec![], 4)?;
-        sample_vec.sort();
+        sample_vec.sort_unstable();
         assert_eq!(sample_vec, vec![10, 11, 12, 13]);
         Ok(())
     }
 
     #[test]
     fn test_quick_sample_climbing_from_12() -> Result<(), GraphError> {
         let mut disco = disco12();
         disco.ensure_undecided()?;
 
         let mut sample_vec = disco.take_quick_sample(vec![12], 4)?;
-        sample_vec.sort();
+        sample_vec.sort_unstable();
         // r12's only parent is r9, whose unique grand-parent through the
         // diamond shape is r4. This ends there because the distance from r4
         // to the root is only 3.
         assert_eq!(sample_vec, vec![4, 9, 12]);
         Ok(())
     }
 
     #[test]
     fn test_children_cache() -> Result<(), GraphError> {
         let mut disco = full_disco();
         disco.ensure_children_cache()?;
 
         let cache = disco.children_cache.unwrap();
         assert_eq!(cache.get(&2).cloned(), Some(vec![4]));
         assert_eq!(cache.get(&10).cloned(), None);
 
         let mut children_4 = cache.get(&4).cloned().unwrap();
-        children_4.sort();
+        children_4.sort_unstable();
         assert_eq!(children_4, vec![5, 6, 7]);
 
         let mut children_7 = cache.get(&7).cloned().unwrap();
-        children_7.sort();
+        children_7.sort_unstable();
         assert_eq!(children_7, vec![9, 11]);
 
         Ok(())
     }
 
     #[test]
     fn test_complete_sample() {
         let mut disco = full_disco();
         let undecided: HashSet<Revision> =
             [4, 7, 9, 2, 3].iter().cloned().collect();
         disco.undecided = Some(undecided);
 
         let mut sample = vec![0];
         disco.random_complete_sample(&mut sample, 3);
         assert_eq!(sample.len(), 3);
 
         let mut sample = vec![2, 4, 7];
         disco.random_complete_sample(&mut sample, 1);
         assert_eq!(sample.len(), 3);
     }
 
     #[test]
     fn test_bidirectional_sample() -> Result<(), GraphError> {
         let mut disco = full_disco();
         disco.undecided = Some((0..=13).into_iter().collect());
 
         let (sample_set, size) = disco.bidirectional_sample(7)?;
         assert_eq!(size, 7);
         let mut sample: Vec<Revision> = sample_set.into_iter().collect();
-        sample.sort();
+        sample.sort_unstable();
         // our DAG is a bit too small for the results to be really interesting
         // at least it shows that
         // - we went both ways
         // - we didn't take all Revisions (6 is not in the sample)
         assert_eq!(sample, vec![0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13]);
         Ok(())
     }
 }

rust/hg-core/src/filepatterns.rs

@@ -1,772 +1,772 b''
 // filepatterns.rs
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Handling of Mercurial-specific patterns.
 
 use crate::{
     utils::{
         files::{canonical_path, get_bytes_from_path, get_path_from_bytes},
         hg_path::{path_to_hg_path_buf, HgPathBuf, HgPathError},
         SliceExt,
     },
     FastHashMap, PatternError,
 };
 use lazy_static::lazy_static;
 use regex::bytes::{NoExpand, Regex};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::vec::Vec;
 
 lazy_static! {
     static ref RE_ESCAPE: Vec<Vec<u8>> = {
         let mut v: Vec<Vec<u8>> = (0..=255).map(|byte| vec![byte]).collect();
         let to_escape = b"()[]{}?*+-|^$\\.&~# \t\n\r\x0b\x0c";
         for byte in to_escape {
             v[*byte as usize].insert(0, b'\\');
         }
         v
     };
 }
 
 /// These are matched in order
 const GLOB_REPLACEMENTS: &[(&[u8], &[u8])] =
     &[(b"*/", b"(?:.*/)?"), (b"*", b".*"), (b"", b"[^/]*")];
 
 /// Appended to the regexp of globs
 const GLOB_SUFFIX: &[u8; 7] = b"(?:/|$)";
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PatternSyntax {
     /// A regular expression
     Regexp,
     /// Glob that matches at the front of the path
     RootGlob,
     /// Glob that matches at any suffix of the path (still anchored at
     /// slashes)
     Glob,
     /// a path relative to repository root, which is matched recursively
     Path,
     /// A path relative to cwd
     RelPath,
     /// an unrooted glob (*.rs matches Rust files in all dirs)
     RelGlob,
     /// A regexp that needn't match the start of a name
     RelRegexp,
     /// A path relative to repository root, which is matched non-recursively
     /// (will not match subdirectories)
     RootFiles,
     /// A file of patterns to read and include
     Include,
     /// A file of patterns to match against files under the same directory
     SubInclude,
     /// SubInclude with the result of parsing the included file
     ///
     /// Note: there is no ExpandedInclude because that expansion can be done
     /// in place by replacing the Include pattern by the included patterns.
     /// SubInclude requires more handling.
     ///
     /// Note: `Box` is used to minimize size impact on other enum variants
     ExpandedSubInclude(Box<SubInclude>),
 }
 
 /// Transforms a glob pattern into a regex
 fn glob_to_re(pat: &[u8]) -> Vec<u8> {
     let mut input = pat;
     let mut res: Vec<u8> = vec![];
     let mut group_depth = 0;
 
     while let Some((c, rest)) = input.split_first() {
         input = rest;
 
         match c {
             b'*' => {
                 for (source, repl) in GLOB_REPLACEMENTS {
                     if let Some(rest) = input.drop_prefix(source) {
                         input = rest;
                         res.extend(*repl);
                         break;
                     }
                 }
             }
             b'?' => res.extend(b"."),
             b'[' => {
                 match input.iter().skip(1).position(|b| *b == b']') {
                     None => res.extend(b"\\["),
                     Some(end) => {
                         // Account for the one we skipped
                         let end = end + 1;
 
                         res.extend(b"[");
 
                         for (i, b) in input[..end].iter().enumerate() {
                             if *b == b'!' && i == 0 {
                                 res.extend(b"^")
                             } else if *b == b'^' && i == 0 {
                                 res.extend(b"\\^")
                             } else if *b == b'\\' {
                                 res.extend(b"\\\\")
                             } else {
                                 res.push(*b)
                             }
                         }
                         res.extend(b"]");
                         input = &input[end + 1..];
                     }
                 }
             }
             b'{' => {
                 group_depth += 1;
                 res.extend(b"(?:")
             }
             b'}' if group_depth > 0 => {
                 group_depth -= 1;
                 res.extend(b")");
             }
             b',' if group_depth > 0 => res.extend(b"|"),
             b'\\' => {
                 let c = {
                     if let Some((c, rest)) = input.split_first() {
                         input = rest;
                         c
                     } else {
                         c
                     }
                 };
                 res.extend(&RE_ESCAPE[*c as usize])
             }
             _ => res.extend(&RE_ESCAPE[*c as usize]),
         }
     }
     res
 }
 
 fn escape_pattern(pattern: &[u8]) -> Vec<u8> {
     pattern
         .iter()
         .flat_map(|c| RE_ESCAPE[*c as usize].clone())
         .collect()
 }
 
 pub fn parse_pattern_syntax(
     kind: &[u8],
 ) -> Result<PatternSyntax, PatternError> {
     match kind {
         b"re:" => Ok(PatternSyntax::Regexp),
         b"path:" => Ok(PatternSyntax::Path),
         b"relpath:" => Ok(PatternSyntax::RelPath),
         b"rootfilesin:" => Ok(PatternSyntax::RootFiles),
         b"relglob:" => Ok(PatternSyntax::RelGlob),
         b"relre:" => Ok(PatternSyntax::RelRegexp),
         b"glob:" => Ok(PatternSyntax::Glob),
         b"rootglob:" => Ok(PatternSyntax::RootGlob),
         b"include:" => Ok(PatternSyntax::Include),
         b"subinclude:" => Ok(PatternSyntax::SubInclude),
         _ => Err(PatternError::UnsupportedSyntax(
             String::from_utf8_lossy(kind).to_string(),
         )),
     }
 }
 
 lazy_static! {
     static ref FLAG_RE: Regex = Regex::new(r"^\(\?[aiLmsux]+\)").unwrap();
 }
 
 /// Builds the regex that corresponds to the given pattern.
 /// If within a `syntax: regexp` context, returns the pattern,
 /// otherwise, returns the corresponding regex.
 fn _build_single_regex(entry: &IgnorePattern) -> Vec<u8> {
     let IgnorePattern {
         syntax, pattern, ..
     } = entry;
     if pattern.is_empty() {
         return vec![];
     }
     match syntax {
         PatternSyntax::Regexp => pattern.to_owned(),
         PatternSyntax::RelRegexp => {
             // The `regex` crate accepts `**` while `re2` and Python's `re`
             // do not. Checking for `*` correctly triggers the same error all
             // engines.
             if pattern[0] == b'^'
                 || pattern[0] == b'*'
                 || pattern.starts_with(b".*")
             {
                 return pattern.to_owned();
             }
             match FLAG_RE.find(pattern) {
                 Some(mat) => {
                     let s = mat.start();
                     let e = mat.end();
                     [
                         &b"(?"[..],
                         &pattern[s + 2..e - 1],
                         &b":"[..],
                         if pattern[e] == b'^'
                             || pattern[e] == b'*'
                             || pattern[e..].starts_with(b".*")
                         {
                             &b""[..]
                         } else {
                             &b".*"[..]
                         },
                         &pattern[e..],
                         &b")"[..],
                     ]
                     .concat()
                 }
                 None => [&b".*"[..], pattern].concat(),
             }
         }
         PatternSyntax::Path | PatternSyntax::RelPath => {
             if pattern == b"." {
                 return vec![];
             }
             [escape_pattern(pattern).as_slice(), b"(?:/|$)"].concat()
         }
         PatternSyntax::RootFiles => {
             let mut res = if pattern == b"." {
                 vec![]
             } else {
                 // Pattern is a directory name.
                 [escape_pattern(pattern).as_slice(), b"/"].concat()
             };
 
             // Anything after the pattern must be a non-directory.
             res.extend(b"[^/]+$");
             res
         }
         PatternSyntax::RelGlob => {
             let glob_re = glob_to_re(pattern);
             if let Some(rest) = glob_re.drop_prefix(b"[^/]*") {
                 [b".*", rest, GLOB_SUFFIX].concat()
             } else {
                 [b"(?:.*/)?", glob_re.as_slice(), GLOB_SUFFIX].concat()
             }
         }
         PatternSyntax::Glob | PatternSyntax::RootGlob => {
             [glob_to_re(pattern).as_slice(), GLOB_SUFFIX].concat()
         }
         PatternSyntax::Include
         | PatternSyntax::SubInclude
         | PatternSyntax::ExpandedSubInclude(_) => unreachable!(),
     }
 }
 
 const GLOB_SPECIAL_CHARACTERS: [u8; 7] =
     [b'*', b'?', b'[', b']', b'{', b'}', b'\\'];
 
 /// TODO support other platforms
 #[cfg(unix)]
 pub fn normalize_path_bytes(bytes: &[u8]) -> Vec<u8> {
     if bytes.is_empty() {
         return b".".to_vec();
     }
     let sep = b'/';
 
     let mut initial_slashes = bytes.iter().take_while(|b| **b == sep).count();
     if initial_slashes > 2 {
         // POSIX allows one or two initial slashes, but treats three or more
         // as single slash.
         initial_slashes = 1;
     }
     let components = bytes
         .split(|b| *b == sep)
         .filter(|c| !(c.is_empty() || c == b"."))
         .fold(vec![], |mut acc, component| {
             if component != b".."
                 || (initial_slashes == 0 && acc.is_empty())
                 || (!acc.is_empty() && acc[acc.len() - 1] == b"..")
             {
                 acc.push(component)
             } else if !acc.is_empty() {
                 acc.pop();
             }
             acc
         });
     let mut new_bytes = components.join(&sep);
 
     if initial_slashes > 0 {
         let mut buf: Vec<_> = (0..initial_slashes).map(|_| sep).collect();
         buf.extend(new_bytes);
         new_bytes = buf;
     }
     if new_bytes.is_empty() {
         b".".to_vec()
     } else {
         new_bytes
     }
 }
 
 /// Wrapper function to `_build_single_regex` that short-circuits 'exact' globs
 /// that don't need to be transformed into a regex.
 pub fn build_single_regex(
     entry: &IgnorePattern,
 ) -> Result<Option<Vec<u8>>, PatternError> {
     let IgnorePattern {
         pattern, syntax, ..
     } = entry;
     let pattern = match syntax {
         PatternSyntax::RootGlob
         | PatternSyntax::Path
         | PatternSyntax::RelGlob
-        | PatternSyntax::RootFiles => normalize_path_bytes(&pattern),
+        | PatternSyntax::RootFiles => normalize_path_bytes(pattern),
         PatternSyntax::Include | PatternSyntax::SubInclude => {
             return Err(PatternError::NonRegexPattern(entry.clone()))
         }
         _ => pattern.to_owned(),
     };
     if *syntax == PatternSyntax::RootGlob
         && !pattern.iter().any(|b| GLOB_SPECIAL_CHARACTERS.contains(b))
     {
         Ok(None)
     } else {
         let mut entry = entry.clone();
         entry.pattern = pattern;
         Ok(Some(_build_single_regex(&entry)))
     }
 }
 
 lazy_static! {
     static ref SYNTAXES: FastHashMap<&'static [u8], &'static [u8]> = {
         let mut m = FastHashMap::default();
 
         m.insert(b"re".as_ref(), b"relre:".as_ref());
         m.insert(b"regexp".as_ref(), b"relre:".as_ref());
         m.insert(b"glob".as_ref(), b"relglob:".as_ref());
         m.insert(b"rootglob".as_ref(), b"rootglob:".as_ref());
         m.insert(b"include".as_ref(), b"include:".as_ref());
         m.insert(b"subinclude".as_ref(), b"subinclude:".as_ref());
         m.insert(b"path".as_ref(), b"path:".as_ref());
         m.insert(b"rootfilesin".as_ref(), b"rootfilesin:".as_ref());
         m
     };
 }
 
 #[derive(Debug)]
 pub enum PatternFileWarning {
     /// (file path, syntax bytes)
     InvalidSyntax(PathBuf, Vec<u8>),
     /// File path
     NoSuchFile(PathBuf),
 }
 
 pub fn parse_pattern_file_contents(
     lines: &[u8],
     file_path: &Path,
     default_syntax_override: Option<&[u8]>,
     warn: bool,
 ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
     let comment_regex = Regex::new(r"((?:^|[^\\])(?:\\\\)*)#.*").unwrap();
 
     #[allow(clippy::trivial_regex)]
     let comment_escape_regex = Regex::new(r"\\#").unwrap();
     let mut inputs: Vec<IgnorePattern> = vec![];
     let mut warnings: Vec<PatternFileWarning> = vec![];
 
     let mut current_syntax =
-        default_syntax_override.unwrap_or(b"relre:".as_ref());
+        default_syntax_override.unwrap_or_else(|| b"relre:".as_ref());
 
     for (line_number, mut line) in lines.split(|c| *c == b'\n').enumerate() {
         let line_number = line_number + 1;
 
         let line_buf;
         if line.contains(&b'#') {
             if let Some(cap) = comment_regex.captures(line) {
                 line = &line[..cap.get(1).unwrap().end()]
             }
             line_buf = comment_escape_regex.replace_all(line, NoExpand(b"#"));
             line = &line_buf;
         }
 
         let mut line = line.trim_end();
 
         if line.is_empty() {
             continue;
         }
 
         if let Some(syntax) = line.drop_prefix(b"syntax:") {
             let syntax = syntax.trim();
 
             if let Some(rel_syntax) = SYNTAXES.get(syntax) {
                 current_syntax = rel_syntax;
             } else if warn {
                 warnings.push(PatternFileWarning::InvalidSyntax(
                     file_path.to_owned(),
                     syntax.to_owned(),
                 ));
             }
             continue;
         }
 
-        let mut line_syntax: &[u8] = &current_syntax;
+        let mut line_syntax: &[u8] = current_syntax;
 
         for (s, rels) in SYNTAXES.iter() {
             if let Some(rest) = line.drop_prefix(rels) {
                 line_syntax = rels;
                 line = rest;
                 break;
             }
             if let Some(rest) = line.drop_prefix(&[s, &b":"[..]].concat()) {
                 line_syntax = rels;
                 line = rest;
                 break;
             }
         }
 
         inputs.push(IgnorePattern::new(
-            parse_pattern_syntax(&line_syntax).map_err(|e| match e {
+            parse_pattern_syntax(line_syntax).map_err(|e| match e {
                 PatternError::UnsupportedSyntax(syntax) => {
                     PatternError::UnsupportedSyntaxInFile(
                         syntax,
                         file_path.to_string_lossy().into(),
                         line_number,
                     )
                 }
                 _ => e,
             })?,
-            &line,
+            line,
             file_path,
         ));
     }
     Ok((inputs, warnings))
 }
 
 pub fn read_pattern_file(
     file_path: &Path,
     warn: bool,
     inspect_pattern_bytes: &mut impl FnMut(&Path, &[u8]),
 ) -> Result<(Vec<IgnorePattern>, Vec<PatternFileWarning>), PatternError> {
     match std::fs::read(file_path) {
         Ok(contents) => {
             inspect_pattern_bytes(file_path, &contents);
             parse_pattern_file_contents(&contents, file_path, None, warn)
         }
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok((
             vec![],
             vec![PatternFileWarning::NoSuchFile(file_path.to_owned())],
         )),
         Err(e) => Err(e.into()),
     }
 }
 
 /// Represents an entry in an "ignore" file.
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct IgnorePattern {
     pub syntax: PatternSyntax,
     pub pattern: Vec<u8>,
     pub source: PathBuf,
 }
 
 impl IgnorePattern {
     pub fn new(syntax: PatternSyntax, pattern: &[u8], source: &Path) -> Self {
         Self {
             syntax,
             pattern: pattern.to_owned(),
             source: source.to_owned(),
         }
     }
 }
 
 pub type PatternResult<T> = Result<T, PatternError>;
 
 /// Wrapper for `read_pattern_file` that also recursively expands `include:`
 /// and `subinclude:` patterns.
 ///
 /// The former are expanded in place, while `PatternSyntax::ExpandedSubInclude`
 /// is used for the latter to form a tree of patterns.
 pub fn get_patterns_from_file(
     pattern_file: &Path,
     root_dir: &Path,
     inspect_pattern_bytes: &mut impl FnMut(&Path, &[u8]),
 ) -> PatternResult<(Vec<IgnorePattern>, Vec<PatternFileWarning>)> {
     let (patterns, mut warnings) =
         read_pattern_file(pattern_file, true, inspect_pattern_bytes)?;
     let patterns = patterns
         .into_iter()
         .flat_map(|entry| -> PatternResult<_> {
             Ok(match &entry.syntax {
                 PatternSyntax::Include => {
                     let inner_include =
                         root_dir.join(get_path_from_bytes(&entry.pattern));
                     let (inner_pats, inner_warnings) = get_patterns_from_file(
                         &inner_include,
                         root_dir,
                         inspect_pattern_bytes,
                     )?;
                     warnings.extend(inner_warnings);
                     inner_pats
                 }
                 PatternSyntax::SubInclude => {
                     let mut sub_include = SubInclude::new(
-                        &root_dir,
+                        root_dir,
                         &entry.pattern,
                         &entry.source,
                     )?;
                     let (inner_patterns, inner_warnings) =
                         get_patterns_from_file(
                             &sub_include.path,
                             &sub_include.root,
                             inspect_pattern_bytes,
                         )?;
                     sub_include.included_patterns = inner_patterns;
                     warnings.extend(inner_warnings);
                     vec![IgnorePattern {
                         syntax: PatternSyntax::ExpandedSubInclude(Box::new(
                             sub_include,
                         )),
                         ..entry
                     }]
                 }
                 _ => vec![entry],
             })
         })
         .flatten()
         .collect();
 
     Ok((patterns, warnings))
 }
 
 /// Holds all the information needed to handle a `subinclude:` pattern.
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct SubInclude {
     /// Will be used for repository (hg) paths that start with this prefix.
     /// It is relative to the current working directory, so comparing against
     /// repository paths is painless.
     pub prefix: HgPathBuf,
     /// The file itself, containing the patterns
     pub path: PathBuf,
     /// Folder in the filesystem where this it applies
     pub root: PathBuf,
 
     pub included_patterns: Vec<IgnorePattern>,
 }
 
 impl SubInclude {
     pub fn new(
         root_dir: &Path,
         pattern: &[u8],
         source: &Path,
     ) -> Result<SubInclude, HgPathError> {
         let normalized_source =
             normalize_path_bytes(&get_bytes_from_path(source));
 
         let source_root = get_path_from_bytes(&normalized_source);
         let source_root =
             source_root.parent().unwrap_or_else(|| source_root.deref());
 
         let path = source_root.join(get_path_from_bytes(pattern));
         let new_root = path.parent().unwrap_or_else(|| path.deref());
 
         let prefix = canonical_path(root_dir, root_dir, new_root)?;
 
         Ok(Self {
-            prefix: path_to_hg_path_buf(prefix).and_then(|mut p| {
+            prefix: path_to_hg_path_buf(prefix).map(|mut p| {
                 if !p.is_empty() {
                     p.push_byte(b'/');
                 }
-                Ok(p)
+                p
             })?,
             path: path.to_owned(),
             root: new_root.to_owned(),
             included_patterns: Vec::new(),
         })
     }
 }
 
 /// Separate and pre-process subincludes from other patterns for the "ignore"
 /// phase.
 pub fn filter_subincludes(
     ignore_patterns: Vec<IgnorePattern>,
 ) -> Result<(Vec<SubInclude>, Vec<IgnorePattern>), HgPathError> {
     let mut subincludes = vec![];
     let mut others = vec![];
 
     for pattern in ignore_patterns {
         if let PatternSyntax::ExpandedSubInclude(sub_include) = pattern.syntax
         {
             subincludes.push(*sub_include);
         } else {
             others.push(pattern)
         }
     }
     Ok((subincludes, others))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
     #[test]
     fn escape_pattern_test() {
         let untouched =
             br#"!"%',/0123456789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ_`abcdefghijklmnopqrstuvwxyz"#;
         assert_eq!(escape_pattern(untouched), untouched.to_vec());
         // All escape codes
         assert_eq!(
             escape_pattern(br#"()[]{}?*+-|^$\\.&~# \t\n\r\v\f"#),
             br#"\(\)\[\]\{\}\?\*\+\-\|\^\$\\\\\.\&\~\#\ \\t\\n\\r\\v\\f"#
                 .to_vec()
         );
     }
 
     #[test]
     fn glob_test() {
         assert_eq!(glob_to_re(br#"?"#), br#"."#);
         assert_eq!(glob_to_re(br#"*"#), br#"[^/]*"#);
         assert_eq!(glob_to_re(br#"**"#), br#".*"#);
         assert_eq!(glob_to_re(br#"**/a"#), br#"(?:.*/)?a"#);
         assert_eq!(glob_to_re(br#"a/**/b"#), br#"a/(?:.*/)?b"#);
         assert_eq!(glob_to_re(br#"[a*?!^][^b][!c]"#), br#"[a*?!^][\^b][^c]"#);
         assert_eq!(glob_to_re(br#"{a,b}"#), br#"(?:a|b)"#);
         assert_eq!(glob_to_re(br#".\*\?"#), br#"\.\*\?"#);
     }
 
     #[test]
     fn test_parse_pattern_file_contents() {
         let lines = b"syntax: glob\n*.elc";
 
         assert_eq!(
             parse_pattern_file_contents(
                 lines,
                 Path::new("file_path"),
                 None,
                 false
             )
             .unwrap()
             .0,
             vec![IgnorePattern::new(
                 PatternSyntax::RelGlob,
                 b"*.elc",
                 Path::new("file_path")
             )],
         );
 
         let lines = b"syntax: include\nsyntax: glob";
 
         assert_eq!(
             parse_pattern_file_contents(
                 lines,
                 Path::new("file_path"),
                 None,
                 false
             )
             .unwrap()
             .0,
             vec![]
         );
         let lines = b"glob:**.o";
         assert_eq!(
             parse_pattern_file_contents(
                 lines,
                 Path::new("file_path"),
                 None,
                 false
             )
             .unwrap()
             .0,
             vec![IgnorePattern::new(
                 PatternSyntax::RelGlob,
                 b"**.o",
                 Path::new("file_path")
             )]
         );
     }
 
     #[test]
     fn test_build_single_regex() {
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RelGlob,
                 b"rust/target/",
                 Path::new("")
             ))
             .unwrap(),
             Some(br"(?:.*/)?rust/target(?:/|$)".to_vec()),
         );
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::Regexp,
                 br"rust/target/\d+",
                 Path::new("")
             ))
             .unwrap(),
             Some(br"rust/target/\d+".to_vec()),
         );
     }
 
     #[test]
     fn test_build_single_regex_shortcut() {
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RootGlob,
                 b"",
                 Path::new("")
             ))
             .unwrap(),
             None,
         );
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RootGlob,
                 b"whatever",
                 Path::new("")
             ))
             .unwrap(),
             None,
         );
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RootGlob,
                 b"*.o",
                 Path::new("")
             ))
             .unwrap(),
             Some(br"[^/]*\.o(?:/|$)".to_vec()),
         );
     }
 
     #[test]
     fn test_build_single_relregex() {
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RelRegexp,
                 b"^ba{2}r",
                 Path::new("")
             ))
             .unwrap(),
             Some(b"^ba{2}r".to_vec()),
         );
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RelRegexp,
                 b"ba{2}r",
                 Path::new("")
             ))
             .unwrap(),
             Some(b".*ba{2}r".to_vec()),
         );
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RelRegexp,
                 b"(?ia)ba{2}r",
                 Path::new("")
             ))
             .unwrap(),
             Some(b"(?ia:.*ba{2}r)".to_vec()),
         );
         assert_eq!(
             build_single_regex(&IgnorePattern::new(
                 PatternSyntax::RelRegexp,
                 b"(?ia)^ba{2}r",
                 Path::new("")
             ))
             .unwrap(),
             Some(b"(?ia:^ba{2}r)".to_vec()),
         );
     }
 }

rust/hg-core/src/lock.rs

@@ -1,186 +1,188 b''
 //! Filesystem-based locks for local repositories
 
 use crate::errors::HgError;
 use crate::errors::HgResultExt;
 use crate::vfs::Vfs;
 use std::io;
 use std::io::ErrorKind;
 
 #[derive(derive_more::From)]
 pub enum LockError {
     AlreadyHeld,
     #[from]
     Other(HgError),
 }
 
 /// Try to call `f` with the lock acquired, without waiting.
 ///
 /// If the lock is aready held, `f` is not called and `LockError::AlreadyHeld`
 /// is returned. `LockError::Io` is returned for any unexpected I/O error
 /// accessing the lock file, including for removing it after `f` was called.
 /// The return value of `f` is dropped in that case. If all is successful, the
 /// return value of `f` is forwarded.
 pub fn try_with_lock_no_wait<R>(
     hg_vfs: Vfs,
     lock_filename: &str,
     f: impl FnOnce() -> R,
 ) -> Result<R, LockError> {
     let our_lock_data = &*OUR_LOCK_DATA;
     for _retry in 0..5 {
         match make_lock(hg_vfs, lock_filename, our_lock_data) {
             Ok(()) => {
                 let result = f();
                 unlock(hg_vfs, lock_filename)?;
                 return Ok(result);
             }
             Err(HgError::IoError { error, .. })
                 if error.kind() == ErrorKind::AlreadyExists =>
             {
                 let lock_data = read_lock(hg_vfs, lock_filename)?;
                 if lock_data.is_none() {
                     // Lock was apparently just released, retry acquiring it
                     continue;
                 }
                 if !lock_should_be_broken(&lock_data) {
                     return Err(LockError::AlreadyHeld);
                 }
                 // The lock file is left over from a process not running
                 // anymore. Break it, but with another lock to
                 // avoid a race.
                 break_lock(hg_vfs, lock_filename)?;
 
                 // Retry acquiring
             }
             Err(error) => Err(error)?,
         }
     }
     Err(LockError::AlreadyHeld)
 }
 
 fn break_lock(hg_vfs: Vfs, lock_filename: &str) -> Result<(), LockError> {
     try_with_lock_no_wait(hg_vfs, &format!("{}.break", lock_filename), || {
         // Check again in case some other process broke and
         // acquired the lock in the meantime
         let lock_data = read_lock(hg_vfs, lock_filename)?;
         if !lock_should_be_broken(&lock_data) {
             return Err(LockError::AlreadyHeld);
         }
         Ok(hg_vfs.remove_file(lock_filename)?)
     })?
 }
 
 #[cfg(unix)]
 fn make_lock(
     hg_vfs: Vfs,
     lock_filename: &str,
     data: &str,
 ) -> Result<(), HgError> {
     // Use a symbolic link because creating it is atomic.
     // The link’s "target" contains data not representing any path.
     let fake_symlink_target = data;
     hg_vfs.create_symlink(lock_filename, fake_symlink_target)
 }
 
 fn read_lock(
     hg_vfs: Vfs,
     lock_filename: &str,
 ) -> Result<Option<String>, HgError> {
     let link_target =
         hg_vfs.read_link(lock_filename).io_not_found_as_none()?;
     if let Some(target) = link_target {
         let data = target
             .into_os_string()
             .into_string()
             .map_err(|_| HgError::corrupted("non-UTF-8 lock data"))?;
         Ok(Some(data))
     } else {
         Ok(None)
     }
 }
 
 fn unlock(hg_vfs: Vfs, lock_filename: &str) -> Result<(), HgError> {
     hg_vfs.remove_file(lock_filename)
 }
 
 /// Return whether the process that is/was holding the lock is known not to be
 /// running anymore.
 fn lock_should_be_broken(data: &Option<String>) -> bool {
     (|| -> Option<bool> {
         let (prefix, pid) = data.as_ref()?.split_once(':')?;
-        if prefix != &*LOCK_PREFIX {
+        if prefix != *LOCK_PREFIX {
             return Some(false);
         }
         let process_is_running;
 
         #[cfg(unix)]
         {
             let pid: libc::pid_t = pid.parse().ok()?;
             unsafe {
                 let signal = 0; // Test if we could send a signal, without sending
                 let result = libc::kill(pid, signal);
                 if result == 0 {
                     process_is_running = true
                 } else {
                     let errno =
                         io::Error::last_os_error().raw_os_error().unwrap();
                     process_is_running = errno != libc::ESRCH
                 }
             }
         }
 
         Some(!process_is_running)
     })()
     .unwrap_or(false)
 }
 
 lazy_static::lazy_static! {
     /// A string which is used to differentiate pid namespaces
     ///
     /// It's useful to detect "dead" processes and remove stale locks with
     /// confidence. Typically it's just hostname. On modern linux, we include an
     /// extra Linux-specific pid namespace identifier.
     static ref LOCK_PREFIX: String = {
         // Note: this must match the behavior of `_getlockprefix` in `mercurial/lock.py`
 
         /// Same as https://github.com/python/cpython/blob/v3.10.0/Modules/socketmodule.c#L5414
         const BUFFER_SIZE: usize = 1024;
+        // This cast is *needed* for platforms with signed chars
+        #[allow(clippy::unnecessary_cast)]
         let mut buffer = [0 as libc::c_char; BUFFER_SIZE];
         let hostname_bytes = unsafe {
             let result = libc::gethostname(buffer.as_mut_ptr(), BUFFER_SIZE);
             if result != 0 {
                 panic!("gethostname: {}", io::Error::last_os_error())
             }
             std::ffi::CStr::from_ptr(buffer.as_mut_ptr()).to_bytes()
         };
         let hostname =
             std::str::from_utf8(hostname_bytes).expect("non-UTF-8 hostname");
 
         #[cfg(target_os = "linux")]
         {
             use std::os::linux::fs::MetadataExt;
             match std::fs::metadata("/proc/self/ns/pid") {
                 Ok(meta) => {
                     return format!("{}/{:x}", hostname, meta.st_ino())
                 }
                 Err(error) => {
                     // TODO: match on `error.kind()` when `NotADirectory`
                     // is available on all supported Rust versions:
                     // https://github.com/rust-lang/rust/issues/86442
                     use libc::{
                         ENOENT, // ErrorKind::NotFound
                         ENOTDIR, // ErrorKind::NotADirectory
                         EACCES, // ErrorKind::PermissionDenied
                     };
                     match error.raw_os_error() {
                         Some(ENOENT) | Some(ENOTDIR) | Some(EACCES) => {}
                         _ => panic!("stat /proc/self/ns/pid: {}", error),
                     }
                 }
             }
         }
 
         hostname.to_owned()
     };
 
     static ref OUR_LOCK_DATA: String = format!("{}:{}", &*LOCK_PREFIX, std::process::id());
 }

rust/hg-core/src/matchers.rs

@@ -1,1719 +1,1717 b''
 // matchers.rs
 //
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 //! Structs and types for matching files and directories.
 
 use crate::{
     dirstate::dirs_multiset::DirsChildrenMultiset,
     filepatterns::{
         build_single_regex, filter_subincludes, get_patterns_from_file,
         PatternFileWarning, PatternResult,
     },
     utils::{
         files::find_dirs,
         hg_path::{HgPath, HgPathBuf},
         Escaped,
     },
     DirsMultiset, DirstateMapError, FastHashMap, IgnorePattern, PatternError,
     PatternSyntax,
 };
 
 use crate::dirstate::status::IgnoreFnType;
 use crate::filepatterns::normalize_path_bytes;
 use std::borrow::ToOwned;
 use std::collections::HashSet;
 use std::fmt::{Display, Error, Formatter};
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
 #[derive(Debug, PartialEq)]
 pub enum VisitChildrenSet {
     /// Don't visit anything
     Empty,
     /// Only visit this directory
     This,
     /// Visit this directory and these subdirectories
     /// TODO Should we implement a `NonEmptyHashSet`?
     Set(HashSet<HgPathBuf>),
     /// Visit this directory and all subdirectories
     Recursive,
 }
 
 pub trait Matcher: core::fmt::Debug {
     /// Explicitly listed files
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>>;
     /// Returns whether `filename` is in `file_set`
     fn exact_match(&self, filename: &HgPath) -> bool;
     /// Returns whether `filename` is matched by this matcher
     fn matches(&self, filename: &HgPath) -> bool;
     /// Decides whether a directory should be visited based on whether it
     /// has potential matches in it or one of its subdirectories, and
     /// potentially lists which subdirectories of that directory should be
     /// visited. This is based on the match's primary, included, and excluded
     /// patterns.
     ///
     /// # Example
     ///
     /// Assume matchers `['path:foo/bar', 'rootfilesin:qux']`, we would
     /// return the following values (assuming the implementation of
     /// visit_children_set is capable of recognizing this; some implementations
     /// are not).
     ///
     /// ```text
     /// ```ignore
     /// '' -> {'foo', 'qux'}
     /// 'baz' -> set()
     /// 'foo' -> {'bar'}
     /// // Ideally this would be `Recursive`, but since the prefix nature of
     /// // matchers is applied to the entire matcher, we have to downgrade this
     /// // to `This` due to the (yet to be implemented in Rust) non-prefix
     /// // `RootFilesIn'-kind matcher being mixed in.
     /// 'foo/bar' -> 'this'
     /// 'qux' -> 'this'
     /// ```
     /// # Important
     ///
     /// Most matchers do not know if they're representing files or
     /// directories. They see `['path:dir/f']` and don't know whether `f` is a
     /// file or a directory, so `visit_children_set('dir')` for most matchers
     /// will return `HashSet{ HgPath { "f" } }`, but if the matcher knows it's
     /// a file (like the yet to be implemented in Rust `ExactMatcher` does),
     /// it may return `VisitChildrenSet::This`.
     /// Do not rely on the return being a `HashSet` indicating that there are
     /// no files in this dir to investigate (or equivalently that if there are
     /// files to investigate in 'dir' that it will always return
     /// `VisitChildrenSet::This`).
     fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet;
     /// Matcher will match everything and `files_set()` will be empty:
     /// optimization might be possible.
     fn matches_everything(&self) -> bool;
     /// Matcher will match exactly the files in `files_set()`: optimization
     /// might be possible.
     fn is_exact(&self) -> bool;
 }
 
 /// Matches everything.
 ///```
 /// use hg::{ matchers::{Matcher, AlwaysMatcher}, utils::hg_path::HgPath };
 ///
 /// let matcher = AlwaysMatcher;
 ///
 /// assert_eq!(matcher.matches(HgPath::new(b"whatever")), true);
 /// assert_eq!(matcher.matches(HgPath::new(b"b.txt")), true);
 /// assert_eq!(matcher.matches(HgPath::new(b"main.c")), true);
 /// assert_eq!(matcher.matches(HgPath::new(br"re:.*\.c$")), true);
 /// ```
 #[derive(Debug)]
 pub struct AlwaysMatcher;
 
 impl Matcher for AlwaysMatcher {
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>> {
         None
     }
     fn exact_match(&self, _filename: &HgPath) -> bool {
         false
     }
     fn matches(&self, _filename: &HgPath) -> bool {
         true
     }
     fn visit_children_set(&self, _directory: &HgPath) -> VisitChildrenSet {
         VisitChildrenSet::Recursive
     }
     fn matches_everything(&self) -> bool {
         true
     }
     fn is_exact(&self) -> bool {
         false
     }
 }
 
 /// Matches nothing.
 #[derive(Debug)]
 pub struct NeverMatcher;
 
 impl Matcher for NeverMatcher {
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>> {
         None
     }
     fn exact_match(&self, _filename: &HgPath) -> bool {
         false
     }
     fn matches(&self, _filename: &HgPath) -> bool {
         false
     }
     fn visit_children_set(&self, _directory: &HgPath) -> VisitChildrenSet {
         VisitChildrenSet::Empty
     }
     fn matches_everything(&self) -> bool {
         false
     }
     fn is_exact(&self) -> bool {
         true
     }
 }
 
 /// Matches the input files exactly. They are interpreted as paths, not
 /// patterns.
 ///
 ///```
 /// use hg::{ matchers::{Matcher, FileMatcher}, utils::hg_path::{HgPath, HgPathBuf} };
 ///
 /// let files = vec![HgPathBuf::from_bytes(b"a.txt"), HgPathBuf::from_bytes(br"re:.*\.c$")];
 /// let matcher = FileMatcher::new(files).unwrap();
 ///
 /// assert_eq!(matcher.matches(HgPath::new(b"a.txt")), true);
 /// assert_eq!(matcher.matches(HgPath::new(b"b.txt")), false);
 /// assert_eq!(matcher.matches(HgPath::new(b"main.c")), false);
 /// assert_eq!(matcher.matches(HgPath::new(br"re:.*\.c$")), true);
 /// ```
 #[derive(Debug)]
 pub struct FileMatcher {
     files: HashSet<HgPathBuf>,
     dirs: DirsMultiset,
 }
 
 impl FileMatcher {
     pub fn new(files: Vec<HgPathBuf>) -> Result<Self, DirstateMapError> {
         let dirs = DirsMultiset::from_manifest(&files)?;
         Ok(Self {
             files: HashSet::from_iter(files.into_iter()),
             dirs,
         })
     }
     fn inner_matches(&self, filename: &HgPath) -> bool {
         self.files.contains(filename.as_ref())
     }
 }
 
 impl Matcher for FileMatcher {
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>> {
         Some(&self.files)
     }
     fn exact_match(&self, filename: &HgPath) -> bool {
         self.inner_matches(filename)
     }
     fn matches(&self, filename: &HgPath) -> bool {
         self.inner_matches(filename)
     }
     fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet {
         if self.files.is_empty() || !self.dirs.contains(&directory) {
             return VisitChildrenSet::Empty;
         }
         let mut candidates: HashSet<HgPathBuf> =
             self.dirs.iter().cloned().collect();
 
         candidates.extend(self.files.iter().cloned());
         candidates.remove(HgPath::new(b""));
 
         if !directory.as_ref().is_empty() {
             let directory = [directory.as_ref().as_bytes(), b"/"].concat();
             candidates = candidates
                 .iter()
                 .filter_map(|c| {
                     if c.as_bytes().starts_with(&directory) {
                         Some(HgPathBuf::from_bytes(
                             &c.as_bytes()[directory.len()..],
                         ))
                     } else {
                         None
                     }
                 })
                 .collect();
         }
 
         // `self.dirs` includes all of the directories, recursively, so if
         // we're attempting to match 'foo/bar/baz.txt', it'll have '', 'foo',
         // 'foo/bar' in it. Thus we can safely ignore a candidate that has a
         // '/' in it, indicating it's for a subdir-of-a-subdir; the immediate
         // subdir will be in there without a slash.
         VisitChildrenSet::Set(
             candidates
                 .into_iter()
                 .filter_map(|c| {
                     if c.bytes().all(|b| *b != b'/') {
                         Some(c)
                     } else {
                         None
                     }
                 })
                 .collect(),
         )
     }
     fn matches_everything(&self) -> bool {
         false
     }
     fn is_exact(&self) -> bool {
         true
     }
 }
 
 /// Matches files that are included in the ignore rules.
 /// ```
 /// use hg::{
 ///     matchers::{IncludeMatcher, Matcher},
 ///     IgnorePattern,
 ///     PatternSyntax,
 ///     utils::hg_path::HgPath
 /// };
 /// use std::path::Path;
 /// ///
 /// let ignore_patterns =
 /// vec![IgnorePattern::new(PatternSyntax::RootGlob, b"this*", Path::new(""))];
 /// let matcher = IncludeMatcher::new(ignore_patterns).unwrap();
 /// ///
 /// assert_eq!(matcher.matches(HgPath::new(b"testing")), false);
 /// assert_eq!(matcher.matches(HgPath::new(b"this should work")), true);
 /// assert_eq!(matcher.matches(HgPath::new(b"this also")), true);
 /// assert_eq!(matcher.matches(HgPath::new(b"but not this")), false);
 /// ```
 pub struct IncludeMatcher<'a> {
     patterns: Vec<u8>,
     match_fn: IgnoreFnType<'a>,
     /// Whether all the patterns match a prefix (i.e. recursively)
     prefix: bool,
     roots: HashSet<HgPathBuf>,
     dirs: HashSet<HgPathBuf>,
     parents: HashSet<HgPathBuf>,
 }
 
 impl core::fmt::Debug for IncludeMatcher<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("IncludeMatcher")
             .field("patterns", &String::from_utf8_lossy(&self.patterns))
             .field("prefix", &self.prefix)
             .field("roots", &self.roots)
             .field("dirs", &self.dirs)
             .field("parents", &self.parents)
             .finish()
     }
 }
 
 impl<'a> Matcher for IncludeMatcher<'a> {
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>> {
         None
     }
 
     fn exact_match(&self, _filename: &HgPath) -> bool {
         false
     }
 
     fn matches(&self, filename: &HgPath) -> bool {
-        (self.match_fn)(filename.as_ref())
+        (self.match_fn)(filename)
     }
 
     fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet {
-        let dir = directory.as_ref();
+        let dir = directory;
         if self.prefix && self.roots.contains(dir) {
             return VisitChildrenSet::Recursive;
         }
         if self.roots.contains(HgPath::new(b""))
             || self.roots.contains(dir)
             || self.dirs.contains(dir)
             || find_dirs(dir).any(|parent_dir| self.roots.contains(parent_dir))
         {
             return VisitChildrenSet::This;
         }
 
-        if self.parents.contains(directory.as_ref()) {
+        if self.parents.contains(dir.as_ref()) {
             let multiset = self.get_all_parents_children();
             if let Some(children) = multiset.get(dir) {
                 return VisitChildrenSet::Set(
-                    children.into_iter().map(HgPathBuf::from).collect(),
+                    children.iter().map(HgPathBuf::from).collect(),
                 );
             }
         }
         VisitChildrenSet::Empty
     }
 
     fn matches_everything(&self) -> bool {
         false
     }
 
     fn is_exact(&self) -> bool {
         false
     }
 }
 
 /// The union of multiple matchers. Will match if any of the matchers match.
 #[derive(Debug)]
 pub struct UnionMatcher {
     matchers: Vec<Box<dyn Matcher + Sync>>,
 }
 
 impl Matcher for UnionMatcher {
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>> {
         None
     }
 
     fn exact_match(&self, _filename: &HgPath) -> bool {
         false
     }
 
     fn matches(&self, filename: &HgPath) -> bool {
         self.matchers.iter().any(|m| m.matches(filename))
     }
 
     fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet {
         let mut result = HashSet::new();
         let mut this = false;
         for matcher in self.matchers.iter() {
             let visit = matcher.visit_children_set(directory);
             match visit {
                 VisitChildrenSet::Empty => continue,
                 VisitChildrenSet::This => {
                     this = true;
                     // Don't break, we might have an 'all' in here.
                     continue;
                 }
                 VisitChildrenSet::Set(set) => {
                     result.extend(set);
                 }
                 VisitChildrenSet::Recursive => {
                     return visit;
                 }
             }
         }
         if this {
             return VisitChildrenSet::This;
         }
         if result.is_empty() {
             VisitChildrenSet::Empty
         } else {
             VisitChildrenSet::Set(result)
         }
     }
 
     fn matches_everything(&self) -> bool {
         // TODO Maybe if all are AlwaysMatcher?
         false
     }
 
     fn is_exact(&self) -> bool {
         false
     }
 }
 
 impl UnionMatcher {
     pub fn new(matchers: Vec<Box<dyn Matcher + Sync>>) -> Self {
         Self { matchers }
     }
 }
 
 #[derive(Debug)]
 pub struct IntersectionMatcher {
     m1: Box<dyn Matcher + Sync>,
     m2: Box<dyn Matcher + Sync>,
     files: Option<HashSet<HgPathBuf>>,
 }
 
 impl Matcher for IntersectionMatcher {
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>> {
         self.files.as_ref()
     }
 
     fn exact_match(&self, filename: &HgPath) -> bool {
         self.files.as_ref().map_or(false, |f| f.contains(filename))
     }
 
     fn matches(&self, filename: &HgPath) -> bool {
         self.m1.matches(filename) && self.m2.matches(filename)
     }
 
     fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet {
         let m1_set = self.m1.visit_children_set(directory);
         if m1_set == VisitChildrenSet::Empty {
             return VisitChildrenSet::Empty;
         }
         let m2_set = self.m2.visit_children_set(directory);
         if m2_set == VisitChildrenSet::Empty {
             return VisitChildrenSet::Empty;
         }
 
         if m1_set == VisitChildrenSet::Recursive {
             return m2_set;
         } else if m2_set == VisitChildrenSet::Recursive {
             return m1_set;
         }
 
         match (&m1_set, &m2_set) {
             (VisitChildrenSet::Recursive, _) => m2_set,
             (_, VisitChildrenSet::Recursive) => m1_set,
             (VisitChildrenSet::This, _) | (_, VisitChildrenSet::This) => {
                 VisitChildrenSet::This
             }
             (VisitChildrenSet::Set(m1), VisitChildrenSet::Set(m2)) => {
-                let set: HashSet<_> = m1.intersection(&m2).cloned().collect();
+                let set: HashSet<_> = m1.intersection(m2).cloned().collect();
                 if set.is_empty() {
                     VisitChildrenSet::Empty
                 } else {
                     VisitChildrenSet::Set(set)
                 }
             }
             _ => unreachable!(),
         }
     }
 
     fn matches_everything(&self) -> bool {
         self.m1.matches_everything() && self.m2.matches_everything()
     }
 
     fn is_exact(&self) -> bool {
         self.m1.is_exact() || self.m2.is_exact()
     }
 }
 
 impl IntersectionMatcher {
     pub fn new(
         mut m1: Box<dyn Matcher + Sync>,
         mut m2: Box<dyn Matcher + Sync>,
     ) -> Self {
         let files = if m1.is_exact() || m2.is_exact() {
             if !m1.is_exact() {
                 std::mem::swap(&mut m1, &mut m2);
             }
             m1.file_set().map(|m1_files| {
                 m1_files.iter().cloned().filter(|f| m2.matches(f)).collect()
             })
         } else {
             None
         };
         Self { m1, m2, files }
     }
 }
 
 #[derive(Debug)]
 pub struct DifferenceMatcher {
     base: Box<dyn Matcher + Sync>,
     excluded: Box<dyn Matcher + Sync>,
     files: Option<HashSet<HgPathBuf>>,
 }
 
 impl Matcher for DifferenceMatcher {
     fn file_set(&self) -> Option<&HashSet<HgPathBuf>> {
         self.files.as_ref()
     }
 
     fn exact_match(&self, filename: &HgPath) -> bool {
         self.files.as_ref().map_or(false, |f| f.contains(filename))
     }
 
     fn matches(&self, filename: &HgPath) -> bool {
         self.base.matches(filename) && !self.excluded.matches(filename)
     }
 
     fn visit_children_set(&self, directory: &HgPath) -> VisitChildrenSet {
         let excluded_set = self.excluded.visit_children_set(directory);
         if excluded_set == VisitChildrenSet::Recursive {
             return VisitChildrenSet::Empty;
         }
         let base_set = self.base.visit_children_set(directory);
         // Possible values for base: 'recursive', 'this', set(...), set()
         // Possible values for excluded:          'this', set(...), set()
         // If excluded has nothing under here that we care about, return base,
         // even if it's 'recursive'.
         if excluded_set == VisitChildrenSet::Empty {
             return base_set;
         }
         match base_set {
             VisitChildrenSet::This | VisitChildrenSet::Recursive => {
                 // Never return 'recursive' here if excluded_set is any kind of
                 // non-empty (either 'this' or set(foo)), since excluded might
                 // return set() for a subdirectory.
                 VisitChildrenSet::This
             }
             set => {
                 // Possible values for base:         set(...), set()
                 // Possible values for excluded: 'this', set(...)
                 // We ignore excluded set results. They're possibly incorrect:
                 //  base = path:dir/subdir
                 //  excluded=rootfilesin:dir,
                 //  visit_children_set(''):
                 //   base returns {'dir'}, excluded returns {'dir'}, if we
                 //   subtracted we'd return set(), which is *not* correct, we
                 //   still need to visit 'dir'!
                 set
             }
         }
     }
 
     fn matches_everything(&self) -> bool {
         false
     }
 
     fn is_exact(&self) -> bool {
         self.base.is_exact()
     }
 }
 
 impl DifferenceMatcher {
     pub fn new(
         base: Box<dyn Matcher + Sync>,
         excluded: Box<dyn Matcher + Sync>,
     ) -> Self {
         let base_is_exact = base.is_exact();
         let base_files = base.file_set().map(ToOwned::to_owned);
         let mut new = Self {
             base,
             excluded,
             files: None,
         };
         if base_is_exact {
             new.files = base_files.map(|files| {
                 files.iter().cloned().filter(|f| new.matches(f)).collect()
             });
         }
         new
     }
 }
 
 /// Wraps [`regex::bytes::Regex`] to improve performance in multithreaded
 /// contexts.
 ///
 /// The `status` algorithm makes heavy use of threads, and calling `is_match`
 /// from many threads at once is prone to contention, probably within the
 /// scratch space needed as the regex DFA is built lazily.
 ///
 /// We are in the process of raising the issue upstream, but for now
 /// the workaround used here is to store the `Regex` in a lazily populated
 /// thread-local variable, sharing the initial read-only compilation, but
 /// not the lazy dfa scratch space mentioned above.
 ///
 /// This reduces the contention observed with 16+ threads, but does not
 /// completely remove it. Hopefully this can be addressed upstream.
 struct RegexMatcher {
     /// Compiled at the start of the status algorithm, used as a base for
     /// cloning in each thread-local `self.local`, thus sharing the expensive
     /// first compilation.
     base: regex::bytes::Regex,
     /// Thread-local variable that holds the `Regex` that is actually queried
     /// from each thread.
     local: thread_local::ThreadLocal<regex::bytes::Regex>,
 }
 
 impl RegexMatcher {
     /// Returns whether the path matches the stored `Regex`.
     pub fn is_match(&self, path: &HgPath) -> bool {
         self.local
             .get_or(|| self.base.clone())
             .is_match(path.as_bytes())
     }
 }
 
 /// Returns a function that matches an `HgPath` against the given regex
 /// pattern.
 ///
 /// This can fail when the pattern is invalid or not supported by the
 /// underlying engine (the `regex` crate), for instance anything with
 /// back-references.
 #[logging_timer::time("trace")]
 fn re_matcher(pattern: &[u8]) -> PatternResult<RegexMatcher> {
     use std::io::Write;
 
     // The `regex` crate adds `.*` to the start and end of expressions if there
     // are no anchors, so add the start anchor.
     let mut escaped_bytes = vec![b'^', b'(', b'?', b':'];
     for byte in pattern {
         if *byte > 127 {
             write!(escaped_bytes, "\\x{:x}", *byte).unwrap();
         } else {
             escaped_bytes.push(*byte);
         }
     }
     escaped_bytes.push(b')');
 
     // Avoid the cost of UTF8 checking
     //
     // # Safety
     // This is safe because we escaped all non-ASCII bytes.
     let pattern_string = unsafe { String::from_utf8_unchecked(escaped_bytes) };
     let re = regex::bytes::RegexBuilder::new(&pattern_string)
         .unicode(false)
         // Big repos with big `.hgignore` will hit the default limit and
         // incur a significant performance hit. One repo's `hg status` hit
         // multiple *minutes*.
         .dfa_size_limit(50 * (1 << 20))
         .build()
         .map_err(|e| PatternError::UnsupportedSyntax(e.to_string()))?;
 
     Ok(RegexMatcher {
         base: re,
         local: Default::default(),
     })
 }
 
 /// Returns the regex pattern and a function that matches an `HgPath` against
 /// said regex formed by the given ignore patterns.
 fn build_regex_match<'a, 'b>(
     ignore_patterns: &'a [IgnorePattern],
 ) -> PatternResult<(Vec<u8>, IgnoreFnType<'b>)> {
     let mut regexps = vec![];
     let mut exact_set = HashSet::new();
 
     for pattern in ignore_patterns {
         if let Some(re) = build_single_regex(pattern)? {
             regexps.push(re);
         } else {
             let exact = normalize_path_bytes(&pattern.pattern);
             exact_set.insert(HgPathBuf::from_bytes(&exact));
         }
     }
 
     let full_regex = regexps.join(&b'|');
 
     // An empty pattern would cause the regex engine to incorrectly match the
     // (empty) root directory
     let func = if !(regexps.is_empty()) {
         let matcher = re_matcher(&full_regex)?;
         let func = move |filename: &HgPath| {
             exact_set.contains(filename) || matcher.is_match(filename)
         };
         Box::new(func) as IgnoreFnType
     } else {
         let func = move |filename: &HgPath| exact_set.contains(filename);
         Box::new(func) as IgnoreFnType
     };
 
     Ok((full_regex, func))
 }
 
 /// Returns roots and directories corresponding to each pattern.
 ///
 /// This calculates the roots and directories exactly matching the patterns and
 /// returns a tuple of (roots, dirs). It does not return other directories
 /// which may also need to be considered, like the parent directories.
 fn roots_and_dirs(
     ignore_patterns: &[IgnorePattern],
 ) -> (Vec<HgPathBuf>, Vec<HgPathBuf>) {
     let mut roots = Vec::new();
     let mut dirs = Vec::new();
 
     for ignore_pattern in ignore_patterns {
         let IgnorePattern {
             syntax, pattern, ..
         } = ignore_pattern;
         match syntax {
             PatternSyntax::RootGlob | PatternSyntax::Glob => {
                 let mut root = HgPathBuf::new();
                 for p in pattern.split(|c| *c == b'/') {
-                    if p.iter().any(|c| match *c {
-                        b'[' | b'{' | b'*' | b'?' => true,
-                        _ => false,
-                    }) {
+                    if p.iter()
+                        .any(|c| matches!(*c, b'[' | b'{' | b'*' | b'?'))
+                    {
                         break;
                     }
                     root.push(HgPathBuf::from_bytes(p).as_ref());
                 }
                 roots.push(root);
             }
             PatternSyntax::Path | PatternSyntax::RelPath => {
                 let pat = HgPath::new(if pattern == b"." {
                     &[] as &[u8]
                 } else {
                     pattern
                 });
                 roots.push(pat.to_owned());
             }
             PatternSyntax::RootFiles => {
                 let pat = if pattern == b"." {
                     &[] as &[u8]
                 } else {
                     pattern
                 };
                 dirs.push(HgPathBuf::from_bytes(pat));
             }
             _ => {
                 roots.push(HgPathBuf::new());
             }
         }
     }
     (roots, dirs)
 }
 
 /// Paths extracted from patterns
 #[derive(Debug, PartialEq)]
 struct RootsDirsAndParents {
     /// Directories to match recursively
     pub roots: HashSet<HgPathBuf>,
     /// Directories to match non-recursively
     pub dirs: HashSet<HgPathBuf>,
     /// Implicitly required directories to go to items in either roots or dirs
     pub parents: HashSet<HgPathBuf>,
 }
 
 /// Extract roots, dirs and parents from patterns.
 fn roots_dirs_and_parents(
     ignore_patterns: &[IgnorePattern],
 ) -> PatternResult<RootsDirsAndParents> {
     let (roots, dirs) = roots_and_dirs(ignore_patterns);
 
     let mut parents = HashSet::new();
 
     parents.extend(
         DirsMultiset::from_manifest(&dirs)
             .map_err(|e| match e {
                 DirstateMapError::InvalidPath(e) => e,
                 _ => unreachable!(),
             })?
             .iter()
             .map(ToOwned::to_owned),
     );
     parents.extend(
         DirsMultiset::from_manifest(&roots)
             .map_err(|e| match e {
                 DirstateMapError::InvalidPath(e) => e,
                 _ => unreachable!(),
             })?
             .iter()
             .map(ToOwned::to_owned),
     );
 
     Ok(RootsDirsAndParents {
         roots: HashSet::from_iter(roots),
         dirs: HashSet::from_iter(dirs),
         parents,
     })
 }
 
 /// Returns a function that checks whether a given file (in the general sense)
 /// should be matched.
-fn build_match<'a, 'b>(
+fn build_match<'a>(
     ignore_patterns: Vec<IgnorePattern>,
-) -> PatternResult<(Vec<u8>, IgnoreFnType<'b>)> {
-    let mut match_funcs: Vec<IgnoreFnType<'b>> = vec![];
+) -> PatternResult<(Vec<u8>, IgnoreFnType<'a>)> {
+    let mut match_funcs: Vec<IgnoreFnType<'a>> = vec![];
     // For debugging and printing
     let mut patterns = vec![];
 
     let (subincludes, ignore_patterns) = filter_subincludes(ignore_patterns)?;
 
     if !subincludes.is_empty() {
         // Build prefix-based matcher functions for subincludes
         let mut submatchers = FastHashMap::default();
         let mut prefixes = vec![];
 
         for sub_include in subincludes {
             let matcher = IncludeMatcher::new(sub_include.included_patterns)?;
             let match_fn =
                 Box::new(move |path: &HgPath| matcher.matches(path));
             prefixes.push(sub_include.prefix.clone());
             submatchers.insert(sub_include.prefix.clone(), match_fn);
         }
 
         let match_subinclude = move |filename: &HgPath| {
             for prefix in prefixes.iter() {
                 if let Some(rel) = filename.relative_to(prefix) {
                     if (submatchers[prefix])(rel) {
                         return true;
                     }
                 }
             }
             false
         };
 
         match_funcs.push(Box::new(match_subinclude));
     }
 
     if !ignore_patterns.is_empty() {
         // Either do dumb matching if all patterns are rootfiles, or match
         // with a regex.
         if ignore_patterns
             .iter()
             .all(|k| k.syntax == PatternSyntax::RootFiles)
         {
             let dirs: HashSet<_> = ignore_patterns
                 .iter()
                 .map(|k| k.pattern.to_owned())
                 .collect();
             let mut dirs_vec: Vec<_> = dirs.iter().cloned().collect();
 
             let match_func = move |path: &HgPath| -> bool {
                 let path = path.as_bytes();
                 let i = path.iter().rfind(|a| **a == b'/');
                 let dir = if let Some(i) = i {
                     &path[..*i as usize]
                 } else {
                     b"."
                 };
                 dirs.contains(dir.deref())
             };
             match_funcs.push(Box::new(match_func));
 
             patterns.extend(b"rootfilesin: ");
             dirs_vec.sort();
             patterns.extend(dirs_vec.escaped_bytes());
         } else {
             let (new_re, match_func) = build_regex_match(&ignore_patterns)?;
             patterns = new_re;
             match_funcs.push(match_func)
         }
     }
 
     Ok(if match_funcs.len() == 1 {
         (patterns, match_funcs.remove(0))
     } else {
         (
             patterns,
             Box::new(move |f: &HgPath| -> bool {
                 match_funcs.iter().any(|match_func| match_func(f))
             }),
         )
     })
 }
 
 /// Parses all "ignore" files with their recursive includes and returns a
 /// function that checks whether a given file (in the general sense) should be
 /// ignored.
 pub fn get_ignore_matcher<'a>(
     mut all_pattern_files: Vec<PathBuf>,
     root_dir: &Path,
     inspect_pattern_bytes: &mut impl FnMut(&Path, &[u8]),
 ) -> PatternResult<(IncludeMatcher<'a>, Vec<PatternFileWarning>)> {
     let mut all_patterns = vec![];
     let mut all_warnings = vec![];
 
     // Sort to make the ordering of calls to `inspect_pattern_bytes`
     // deterministic even if the ordering of `all_pattern_files` is not (such
     // as when a iteration order of a Python dict or Rust HashMap is involved).
     // Sort by "string" representation instead of the default by component
     // (with a Rust-specific definition of a component)
     all_pattern_files
         .sort_unstable_by(|a, b| a.as_os_str().cmp(b.as_os_str()));
 
     for pattern_file in &all_pattern_files {
         let (patterns, warnings) = get_patterns_from_file(
             pattern_file,
             root_dir,
             inspect_pattern_bytes,
         )?;
 
         all_patterns.extend(patterns.to_owned());
         all_warnings.extend(warnings);
     }
     let matcher = IncludeMatcher::new(all_patterns)?;
     Ok((matcher, all_warnings))
 }
 
 /// Parses all "ignore" files with their recursive includes and returns a
 /// function that checks whether a given file (in the general sense) should be
 /// ignored.
 pub fn get_ignore_function<'a>(
     all_pattern_files: Vec<PathBuf>,
     root_dir: &Path,
     inspect_pattern_bytes: &mut impl FnMut(&Path, &[u8]),
 ) -> PatternResult<(IgnoreFnType<'a>, Vec<PatternFileWarning>)> {
     let res =
         get_ignore_matcher(all_pattern_files, root_dir, inspect_pattern_bytes);
     res.map(|(matcher, all_warnings)| {
         let res: IgnoreFnType<'a> =
             Box::new(move |path: &HgPath| matcher.matches(path));
 
         (res, all_warnings)
     })
 }
 
 impl<'a> IncludeMatcher<'a> {
     pub fn new(ignore_patterns: Vec<IgnorePattern>) -> PatternResult<Self> {
         let RootsDirsAndParents {
             roots,
             dirs,
             parents,
         } = roots_dirs_and_parents(&ignore_patterns)?;
-        let prefix = ignore_patterns.iter().all(|k| match k.syntax {
-            PatternSyntax::Path | PatternSyntax::RelPath => true,
-            _ => false,
+        let prefix = ignore_patterns.iter().all(|k| {
+            matches!(k.syntax, PatternSyntax::Path | PatternSyntax::RelPath)
         });
         let (patterns, match_fn) = build_match(ignore_patterns)?;
 
         Ok(Self {
             patterns,
             match_fn,
             prefix,
             roots,
             dirs,
             parents,
         })
     }
 
     fn get_all_parents_children(&self) -> DirsChildrenMultiset {
         // TODO cache
         let thing = self
             .dirs
             .iter()
             .chain(self.roots.iter())
             .chain(self.parents.iter());
         DirsChildrenMultiset::new(thing, Some(&self.parents))
     }
 
     pub fn debug_get_patterns(&self) -> &[u8] {
         self.patterns.as_ref()
     }
 }
 
 impl<'a> Display for IncludeMatcher<'a> {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
         // XXX What about exact matches?
         // I'm not sure it's worth it to clone the HashSet and keep it
         // around just in case someone wants to display the matcher, plus
         // it's going to be unreadable after a few entries, but we need to
         // inform in this display that exact matches are being used and are
         // (on purpose) missing from the `includes`.
         write!(
             f,
             "IncludeMatcher(includes='{}')",
             String::from_utf8_lossy(&self.patterns.escaped_bytes())
         )
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
     use std::path::Path;
 
     #[test]
     fn test_roots_and_dirs() {
         let pats = vec![
             IgnorePattern::new(PatternSyntax::Glob, b"g/h/*", Path::new("")),
             IgnorePattern::new(PatternSyntax::Glob, b"g/h", Path::new("")),
             IgnorePattern::new(PatternSyntax::Glob, b"g*", Path::new("")),
         ];
         let (roots, dirs) = roots_and_dirs(&pats);
 
         assert_eq!(
             roots,
             vec!(
                 HgPathBuf::from_bytes(b"g/h"),
                 HgPathBuf::from_bytes(b"g/h"),
                 HgPathBuf::new()
             ),
         );
         assert_eq!(dirs, vec!());
     }
 
     #[test]
     fn test_roots_dirs_and_parents() {
         let pats = vec![
             IgnorePattern::new(PatternSyntax::Glob, b"g/h/*", Path::new("")),
             IgnorePattern::new(PatternSyntax::Glob, b"g/h", Path::new("")),
             IgnorePattern::new(PatternSyntax::Glob, b"g*", Path::new("")),
         ];
 
         let mut roots = HashSet::new();
         roots.insert(HgPathBuf::from_bytes(b"g/h"));
         roots.insert(HgPathBuf::new());
 
         let dirs = HashSet::new();
 
         let mut parents = HashSet::new();
         parents.insert(HgPathBuf::new());
         parents.insert(HgPathBuf::from_bytes(b"g"));
 
         assert_eq!(
             roots_dirs_and_parents(&pats).unwrap(),
             RootsDirsAndParents {
                 roots,
                 dirs,
                 parents
             }
         );
     }
 
     #[test]
     fn test_filematcher_visit_children_set() {
         // Visitchildrenset
         let files = vec![HgPathBuf::from_bytes(b"dir/subdir/foo.txt")];
         let matcher = FileMatcher::new(files).unwrap();
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"foo.txt"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Set(set)
         );
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/foo.txt")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
     }
 
     #[test]
     fn test_filematcher_visit_children_set_files_and_dirs() {
         let files = vec![
             HgPathBuf::from_bytes(b"rootfile.txt"),
             HgPathBuf::from_bytes(b"a/file1.txt"),
             HgPathBuf::from_bytes(b"a/b/file2.txt"),
             // No file in a/b/c
             HgPathBuf::from_bytes(b"a/b/c/d/file4.txt"),
         ];
         let matcher = FileMatcher::new(files).unwrap();
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"a"));
         set.insert(HgPathBuf::from_bytes(b"rootfile.txt"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"b"));
         set.insert(HgPathBuf::from_bytes(b"file1.txt"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"a")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"c"));
         set.insert(HgPathBuf::from_bytes(b"file2.txt"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"a/b")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"d"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"a/b/c")),
             VisitChildrenSet::Set(set)
         );
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"file4.txt"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"a/b/c/d")),
             VisitChildrenSet::Set(set)
         );
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"a/b/c/d/e")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
     }
 
     #[test]
     fn test_includematcher() {
         // VisitchildrensetPrefix
         let matcher = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RelPath,
             b"dir/subdir",
             Path::new(""),
         )])
         .unwrap();
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Recursive
         );
         // OPT: This should probably be 'all' if its parent is?
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
 
         // VisitchildrensetRootfilesin
         let matcher = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RootFiles,
             b"dir/subdir",
             Path::new(""),
         )])
         .unwrap();
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
 
         // VisitchildrensetGlob
         let matcher = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::Glob,
             b"dir/z*",
             Path::new(""),
         )])
         .unwrap();
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::This
         );
         // OPT: these should probably be set().
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::This
         );
 
         // Test multiple patterns
         let matcher = IncludeMatcher::new(vec![
             IgnorePattern::new(PatternSyntax::RelPath, b"foo", Path::new("")),
             IgnorePattern::new(PatternSyntax::Glob, b"g*", Path::new("")),
         ])
         .unwrap();
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::This
         );
 
         // Test multiple patterns
         let matcher = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::Glob,
             b"**/*.exe",
             Path::new(""),
         )])
         .unwrap();
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::This
         );
     }
 
     #[test]
     fn test_unionmatcher() {
         // Path + Rootfiles
         let m1 = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RelPath,
             b"dir/subdir",
             Path::new(""),
         )])
         .unwrap();
         let m2 = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RootFiles,
             b"dir",
             Path::new(""),
         )])
         .unwrap();
         let matcher = UnionMatcher::new(vec![Box::new(m1), Box::new(m2)]);
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Recursive
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
 
         // OPT: These next two could be 'all' instead of 'this'.
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::This
         );
 
         // Path + unrelated Path
         let m1 = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RelPath,
             b"dir/subdir",
             Path::new(""),
         )])
         .unwrap();
         let m2 = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RelPath,
             b"folder",
             Path::new(""),
         )])
         .unwrap();
         let matcher = UnionMatcher::new(vec![Box::new(m1), Box::new(m2)]);
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"folder"));
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Recursive
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Recursive
         );
         // OPT: These next two could be 'all' instead of 'this'.
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::This
         );
 
         // Path + subpath
         let m1 = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RelPath,
             b"dir/subdir/x",
             Path::new(""),
         )])
         .unwrap();
         let m2 = IncludeMatcher::new(vec![IgnorePattern::new(
             PatternSyntax::RelPath,
             b"dir/subdir",
             Path::new(""),
         )])
         .unwrap();
         let matcher = UnionMatcher::new(vec![Box::new(m1), Box::new(m2)]);
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Recursive
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::Recursive
         );
         // OPT: this should probably be 'all' not 'this'.
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::This
         );
     }
 
     #[test]
     fn test_intersectionmatcher() {
         // Include path + Include rootfiles
         let m1 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"dir/subdir",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let m2 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RootFiles,
                 b"dir",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let matcher = IntersectionMatcher::new(m1, m2);
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::Empty
         );
 
         // Non intersecting paths
         let m1 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"dir/subdir",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let m2 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"folder",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let matcher = IntersectionMatcher::new(m1, m2);
 
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::Empty
         );
 
         // Nested paths
         let m1 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"dir/subdir/x",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let m2 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"dir/subdir",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let matcher = IntersectionMatcher::new(m1, m2);
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"x"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Set(set)
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::Empty
         );
         // OPT: this should probably be 'all' not 'this'.
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::This
         );
 
         // Diverging paths
         let m1 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"dir/subdir/x",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let m2 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"dir/subdir/z",
                 Path::new(""),
             )])
             .unwrap(),
         );
         let matcher = IntersectionMatcher::new(m1, m2);
 
         // OPT: these next two could probably be Empty as well.
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
         // OPT: these next two could probably be Empty as well.
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::Empty
         );
     }
 
     #[test]
     fn test_differencematcher() {
         // Two alwaysmatchers should function like a nevermatcher
         let m1 = AlwaysMatcher;
         let m2 = AlwaysMatcher;
         let matcher = DifferenceMatcher::new(Box::new(m1), Box::new(m2));
 
         for case in &[
             &b""[..],
             b"dir",
             b"dir/subdir",
             b"dir/subdir/z",
             b"dir/foo",
             b"dir/subdir/x",
             b"folder",
         ] {
             assert_eq!(
                 matcher.visit_children_set(HgPath::new(case)),
                 VisitChildrenSet::Empty
             );
         }
 
         // One always and one never should behave the same as an always
         let m1 = AlwaysMatcher;
         let m2 = NeverMatcher;
         let matcher = DifferenceMatcher::new(Box::new(m1), Box::new(m2));
 
         for case in &[
             &b""[..],
             b"dir",
             b"dir/subdir",
             b"dir/subdir/z",
             b"dir/foo",
             b"dir/subdir/x",
             b"folder",
         ] {
             assert_eq!(
                 matcher.visit_children_set(HgPath::new(case)),
                 VisitChildrenSet::Recursive
             );
         }
 
         // Two include matchers
         let m1 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RelPath,
                 b"dir/subdir",
                 Path::new("/repo"),
             )])
             .unwrap(),
         );
         let m2 = Box::new(
             IncludeMatcher::new(vec![IgnorePattern::new(
                 PatternSyntax::RootFiles,
                 b"dir",
                 Path::new("/repo"),
             )])
             .unwrap(),
         );
 
         let matcher = DifferenceMatcher::new(m1, m2);
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"dir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"")),
             VisitChildrenSet::Set(set)
         );
 
         let mut set = HashSet::new();
         set.insert(HgPathBuf::from_bytes(b"subdir"));
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir")),
             VisitChildrenSet::Set(set)
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir")),
             VisitChildrenSet::Recursive
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/foo")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"folder")),
             VisitChildrenSet::Empty
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/z")),
             VisitChildrenSet::This
         );
         assert_eq!(
             matcher.visit_children_set(HgPath::new(b"dir/subdir/x")),
             VisitChildrenSet::This
         );
     }
 }

rust/hg-core/src/narrow.rs

@@ -1,111 +1,113 b''
 use std::path::Path;
 
 use crate::{
     errors::HgError,
     exit_codes,
     filepatterns::parse_pattern_file_contents,
     matchers::{
         AlwaysMatcher, DifferenceMatcher, IncludeMatcher, Matcher,
         NeverMatcher,
     },
     repo::Repo,
     requirements::NARROW_REQUIREMENT,
     sparse::{self, SparseConfigError, SparseWarning},
 };
 
 /// The file in .hg/store/ that indicates which paths exit in the store
 const FILENAME: &str = "narrowspec";
 /// The file in .hg/ that indicates which paths exit in the dirstate
 const DIRSTATE_FILENAME: &str = "narrowspec.dirstate";
 
 /// Pattern prefixes that are allowed in narrow patterns. This list MUST
 /// only contain patterns that are fast and safe to evaluate. Keep in mind
 /// that patterns are supplied by clients and executed on remote servers
 /// as part of wire protocol commands. That means that changes to this
 /// data structure influence the wire protocol and should not be taken
 /// lightly - especially removals.
 const VALID_PREFIXES: [&str; 2] = ["path:", "rootfilesin:"];
 
 /// Return the matcher for the current narrow spec, and all configuration
 /// warnings to display.
 pub fn matcher(
     repo: &Repo,
 ) -> Result<(Box<dyn Matcher + Sync>, Vec<SparseWarning>), SparseConfigError> {
     let mut warnings = vec![];
     if !repo.requirements().contains(NARROW_REQUIREMENT) {
         return Ok((Box::new(AlwaysMatcher), warnings));
     }
     // Treat "narrowspec does not exist" the same as "narrowspec file exists
     // and is empty".
-    let store_spec = repo.store_vfs().try_read(FILENAME)?.unwrap_or(vec![]);
-    let working_copy_spec =
-        repo.hg_vfs().try_read(DIRSTATE_FILENAME)?.unwrap_or(vec![]);
+    let store_spec = repo.store_vfs().try_read(FILENAME)?.unwrap_or_default();
+    let working_copy_spec = repo
+        .hg_vfs()
+        .try_read(DIRSTATE_FILENAME)?
+        .unwrap_or_default();
     if store_spec != working_copy_spec {
         return Err(HgError::abort(
             "working copy's narrowspec is stale",
             exit_codes::STATE_ERROR,
             Some("run 'hg tracked --update-working-copy'".into()),
         )
         .into());
     }
 
     let config = sparse::parse_config(
         &store_spec,
         sparse::SparseConfigContext::Narrow,
     )?;
 
     warnings.extend(config.warnings);
 
     if !config.profiles.is_empty() {
         // TODO (from Python impl) maybe do something with profiles?
         return Err(SparseConfigError::IncludesInNarrow);
     }
     validate_patterns(&config.includes)?;
     validate_patterns(&config.excludes)?;
 
     if config.includes.is_empty() {
         return Ok((Box::new(NeverMatcher), warnings));
     }
 
     let (patterns, subwarnings) = parse_pattern_file_contents(
         &config.includes,
         Path::new(""),
         None,
         false,
     )?;
     warnings.extend(subwarnings.into_iter().map(From::from));
 
     let mut m: Box<dyn Matcher + Sync> =
         Box::new(IncludeMatcher::new(patterns)?);
 
     let (patterns, subwarnings) = parse_pattern_file_contents(
         &config.excludes,
         Path::new(""),
         None,
         false,
     )?;
     if !patterns.is_empty() {
         warnings.extend(subwarnings.into_iter().map(From::from));
         let exclude_matcher = Box::new(IncludeMatcher::new(patterns)?);
         m = Box::new(DifferenceMatcher::new(m, exclude_matcher));
     }
 
     Ok((m, warnings))
 }
 
 fn validate_patterns(patterns: &[u8]) -> Result<(), SparseConfigError> {
     for pattern in patterns.split(|c| *c == b'\n') {
         if pattern.is_empty() {
             continue;
         }
         for prefix in VALID_PREFIXES.iter() {
             if pattern.starts_with(prefix.as_bytes()) {
                 return Ok(());
             }
         }
         return Err(SparseConfigError::InvalidNarrowPrefix(
             pattern.to_owned(),
         ));
     }
     Ok(())
 }

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

@@ -1,117 +1,115 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::repo::Repo;
 use crate::revlog::revlog::RevlogError;
 use crate::revlog::Node;
 
 use crate::utils::hg_path::HgPath;
 
 use crate::errors::HgError;
 use crate::manifest::Manifest;
 use crate::manifest::ManifestEntry;
 use itertools::put_back;
 use itertools::PutBack;
 use std::cmp::Ordering;
 
 pub struct CatOutput<'a> {
     /// Whether any file in the manifest matched the paths given as CLI
     /// arguments
     pub found_any: bool,
     /// The contents of matching files, in manifest order
     pub results: Vec<(&'a HgPath, Vec<u8>)>,
     /// Which of the CLI arguments did not match any manifest file
     pub missing: Vec<&'a HgPath>,
     /// The node ID that the given revset was resolved to
     pub node: Node,
 }
 
 // Find an item in an iterator over a sorted collection.
 fn find_item<'a>(
     i: &mut PutBack<impl Iterator<Item = Result<ManifestEntry<'a>, HgError>>>,
     needle: &HgPath,
 ) -> Result<Option<Node>, HgError> {
     loop {
         match i.next() {
             None => return Ok(None),
             Some(result) => {
                 let entry = result?;
                 match needle.as_bytes().cmp(entry.path.as_bytes()) {
                     Ordering::Less => {
                         i.put_back(Ok(entry));
                         return Ok(None);
                     }
                     Ordering::Greater => continue,
                     Ordering::Equal => return Ok(Some(entry.node_id()?)),
                 }
             }
         }
     }
 }
 
 // Tuple of (missing, found) paths in the manifest
 type ManifestQueryResponse<'a> = (Vec<(&'a HgPath, Node)>, Vec<&'a HgPath>);
 
 fn find_files_in_manifest<'query>(
     manifest: &Manifest,
     query: impl Iterator<Item = &'query HgPath>,
 ) -> Result<ManifestQueryResponse<'query>, HgError> {
     let mut manifest = put_back(manifest.iter());
     let mut res = vec![];
     let mut missing = vec![];
 
     for file in query {
         match find_item(&mut manifest, file)? {
             None => missing.push(file),
             Some(item) => res.push((file, item)),
         }
     }
-    return Ok((res, missing));
+    Ok((res, missing))
 }
 
 /// Output the given revision of files
 ///
 /// * `root`: Repository root
 /// * `rev`: The revision to cat the files from.
 /// * `files`: The files to output.
 pub fn cat<'a>(
     repo: &Repo,
     revset: &str,
     mut files: Vec<&'a HgPath>,
 ) -> Result<CatOutput<'a>, RevlogError> {
     let rev = crate::revset::resolve_single(revset, repo)?;
     let manifest = repo.manifest_for_rev(rev)?;
     let node = *repo
         .changelog()?
         .node_from_rev(rev)
         .expect("should succeed when repo.manifest did");
     let mut results: Vec<(&'a HgPath, Vec<u8>)> = vec![];
     let mut found_any = false;
 
     files.sort_unstable();
 
-    let (found, missing) = find_files_in_manifest(
-        &manifest,
-        files.into_iter().map(|f| f.as_ref()),
-    )?;
+    let (found, missing) =
+        find_files_in_manifest(&manifest, files.into_iter())?;
 
     for (file_path, file_node) in found {
         found_any = true;
         let file_log = repo.filelog(file_path)?;
         results.push((
             file_path,
             file_log.data_for_node(file_node)?.into_file_data()?,
         ));
     }
 
     Ok(CatOutput {
         found_any,
         results,
         missing,
         node,
     })
 }

rust/hg-core/src/repo.rs

@@ -1,567 +1,563 b''
 use crate::changelog::Changelog;
 use crate::config::{Config, ConfigError, ConfigParseError};
 use crate::dirstate::DirstateParents;
 use crate::dirstate_tree::on_disk::Docket as DirstateDocket;
 use crate::dirstate_tree::owning::OwningDirstateMap;
 use crate::errors::HgResultExt;
 use crate::errors::{HgError, IoResultExt};
 use crate::lock::{try_with_lock_no_wait, LockError};
 use crate::manifest::{Manifest, Manifestlog};
 use crate::revlog::filelog::Filelog;
 use crate::revlog::revlog::RevlogError;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::HgPath;
 use crate::utils::SliceExt;
 use crate::vfs::{is_dir, is_file, Vfs};
 use crate::{requirements, NodePrefix};
 use crate::{DirstateError, Revision};
 use std::cell::{Ref, RefCell, RefMut};
 use std::collections::HashSet;
 use std::io::Seek;
 use std::io::SeekFrom;
 use std::io::Write as IoWrite;
 use std::path::{Path, PathBuf};
 
 /// A repository on disk
 pub struct Repo {
     working_directory: PathBuf,
     dot_hg: PathBuf,
     store: PathBuf,
     requirements: HashSet<String>,
     config: Config,
     dirstate_parents: LazyCell<DirstateParents>,
     dirstate_data_file_uuid: LazyCell<Option<Vec<u8>>>,
     dirstate_map: LazyCell<OwningDirstateMap>,
     changelog: LazyCell<Changelog>,
     manifestlog: LazyCell<Manifestlog>,
 }
 
 #[derive(Debug, derive_more::From)]
 pub enum RepoError {
     NotFound {
         at: PathBuf,
     },
     #[from]
     ConfigParseError(ConfigParseError),
     #[from]
     Other(HgError),
 }
 
 impl From<ConfigError> for RepoError {
     fn from(error: ConfigError) -> Self {
         match error {
             ConfigError::Parse(error) => error.into(),
             ConfigError::Other(error) => error.into(),
         }
     }
 }
 
 impl Repo {
     /// tries to find nearest repository root in current working directory or
     /// its ancestors
     pub fn find_repo_root() -> Result<PathBuf, RepoError> {
         let current_directory = crate::utils::current_dir()?;
         // ancestors() is inclusive: it first yields `current_directory`
         // as-is.
         for ancestor in current_directory.ancestors() {
             if is_dir(ancestor.join(".hg"))? {
                 return Ok(ancestor.to_path_buf());
             }
         }
-        return Err(RepoError::NotFound {
+        Err(RepoError::NotFound {
             at: current_directory,
-        });
+        })
     }
 
     /// Find a repository, either at the given path (which must contain a `.hg`
     /// sub-directory) or by searching the current directory and its
     /// ancestors.
     ///
     /// A method with two very different "modes" like this usually a code smell
     /// to make two methods instead, but in this case an `Option` is what rhg
     /// sub-commands get from Clap for the `-R` / `--repository` CLI argument.
     /// Having two methods would just move that `if` to almost all callers.
     pub fn find(
         config: &Config,
         explicit_path: Option<PathBuf>,
     ) -> Result<Self, RepoError> {
         if let Some(root) = explicit_path {
             if is_dir(root.join(".hg"))? {
-                Self::new_at_path(root.to_owned(), config)
+                Self::new_at_path(root, config)
             } else if is_file(&root)? {
                 Err(HgError::unsupported("bundle repository").into())
             } else {
-                Err(RepoError::NotFound {
-                    at: root.to_owned(),
-                })
+                Err(RepoError::NotFound { at: root })
             }
         } else {
             let root = Self::find_repo_root()?;
             Self::new_at_path(root, config)
         }
     }
 
     /// To be called after checking that `.hg` is a sub-directory
     fn new_at_path(
         working_directory: PathBuf,
         config: &Config,
     ) -> Result<Self, RepoError> {
         let dot_hg = working_directory.join(".hg");
 
-        let mut repo_config_files = Vec::new();
-        repo_config_files.push(dot_hg.join("hgrc"));
-        repo_config_files.push(dot_hg.join("hgrc-not-shared"));
+        let mut repo_config_files =
+            vec![dot_hg.join("hgrc"), dot_hg.join("hgrc-not-shared")];
 
         let hg_vfs = Vfs { base: &dot_hg };
         let mut reqs = requirements::load_if_exists(hg_vfs)?;
         let relative =
             reqs.contains(requirements::RELATIVE_SHARED_REQUIREMENT);
         let shared =
             reqs.contains(requirements::SHARED_REQUIREMENT) || relative;
 
         // From `mercurial/localrepo.py`:
         //
         // if .hg/requires contains the sharesafe requirement, it means
         // there exists a `.hg/store/requires` too and we should read it
         // NOTE: presence of SHARESAFE_REQUIREMENT imply that store requirement
         // is present. We never write SHARESAFE_REQUIREMENT for a repo if store
         // is not present, refer checkrequirementscompat() for that
         //
         // However, if SHARESAFE_REQUIREMENT is not present, it means that the
         // repository was shared the old way. We check the share source
         // .hg/requires for SHARESAFE_REQUIREMENT to detect whether the
         // current repository needs to be reshared
         let share_safe = reqs.contains(requirements::SHARESAFE_REQUIREMENT);
 
         let store_path;
         if !shared {
             store_path = dot_hg.join("store");
         } else {
             let bytes = hg_vfs.read("sharedpath")?;
             let mut shared_path =
                 get_path_from_bytes(bytes.trim_end_matches(|b| b == b'\n'))
                     .to_owned();
             if relative {
                 shared_path = dot_hg.join(shared_path)
             }
             if !is_dir(&shared_path)? {
                 return Err(HgError::corrupted(format!(
                     ".hg/sharedpath points to nonexistent directory {}",
                     shared_path.display()
                 ))
                 .into());
             }
 
             store_path = shared_path.join("store");
 
             let source_is_share_safe =
                 requirements::load(Vfs { base: &shared_path })?
                     .contains(requirements::SHARESAFE_REQUIREMENT);
 
             if share_safe != source_is_share_safe {
                 return Err(HgError::unsupported("share-safe mismatch").into());
             }
 
             if share_safe {
                 repo_config_files.insert(0, shared_path.join("hgrc"))
             }
         }
         if share_safe {
             reqs.extend(requirements::load(Vfs { base: &store_path })?);
         }
 
         let repo_config = if std::env::var_os("HGRCSKIPREPO").is_none() {
             config.combine_with_repo(&repo_config_files)?
         } else {
             config.clone()
         };
 
         let repo = Self {
             requirements: reqs,
             working_directory,
             store: store_path,
             dot_hg,
             config: repo_config,
             dirstate_parents: LazyCell::new(),
             dirstate_data_file_uuid: LazyCell::new(),
             dirstate_map: LazyCell::new(),
             changelog: LazyCell::new(),
             manifestlog: LazyCell::new(),
         };
 
         requirements::check(&repo)?;
 
         Ok(repo)
     }
 
     pub fn working_directory_path(&self) -> &Path {
         &self.working_directory
     }
 
     pub fn requirements(&self) -> &HashSet<String> {
         &self.requirements
     }
 
     pub fn config(&self) -> &Config {
         &self.config
     }
 
     /// For accessing repository files (in `.hg`), except for the store
     /// (`.hg/store`).
     pub fn hg_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.dot_hg }
     }
 
     /// For accessing repository store files (in `.hg/store`)
     pub fn store_vfs(&self) -> Vfs<'_> {
         Vfs { base: &self.store }
     }
 
     /// For accessing the working copy
     pub fn working_directory_vfs(&self) -> Vfs<'_> {
         Vfs {
             base: &self.working_directory,
         }
     }
 
     pub fn try_with_wlock_no_wait<R>(
         &self,
         f: impl FnOnce() -> R,
     ) -> Result<R, LockError> {
         try_with_lock_no_wait(self.hg_vfs(), "wlock", f)
     }
 
     pub fn has_dirstate_v2(&self) -> bool {
         self.requirements
             .contains(requirements::DIRSTATE_V2_REQUIREMENT)
     }
 
     pub fn has_sparse(&self) -> bool {
         self.requirements.contains(requirements::SPARSE_REQUIREMENT)
     }
 
     pub fn has_narrow(&self) -> bool {
         self.requirements.contains(requirements::NARROW_REQUIREMENT)
     }
 
     pub fn has_nodemap(&self) -> bool {
         self.requirements
             .contains(requirements::NODEMAP_REQUIREMENT)
     }
 
     fn dirstate_file_contents(&self) -> Result<Vec<u8>, HgError> {
         Ok(self
             .hg_vfs()
             .read("dirstate")
             .io_not_found_as_none()?
-            .unwrap_or(Vec::new()))
+            .unwrap_or_default())
     }
 
     pub fn dirstate_parents(&self) -> Result<DirstateParents, HgError> {
         Ok(*self
             .dirstate_parents
             .get_or_init(|| self.read_dirstate_parents())?)
     }
 
     fn read_dirstate_parents(&self) -> Result<DirstateParents, HgError> {
         let dirstate = self.dirstate_file_contents()?;
         let parents = if dirstate.is_empty() {
             if self.has_dirstate_v2() {
                 self.dirstate_data_file_uuid.set(None);
             }
             DirstateParents::NULL
         } else if self.has_dirstate_v2() {
             let docket =
                 crate::dirstate_tree::on_disk::read_docket(&dirstate)?;
             self.dirstate_data_file_uuid
                 .set(Some(docket.uuid.to_owned()));
             docket.parents()
         } else {
-            crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
-                .clone()
+            *crate::dirstate::parsers::parse_dirstate_parents(&dirstate)?
         };
         self.dirstate_parents.set(parents);
         Ok(parents)
     }
 
     fn read_dirstate_data_file_uuid(
         &self,
     ) -> Result<Option<Vec<u8>>, HgError> {
         assert!(
             self.has_dirstate_v2(),
             "accessing dirstate data file ID without dirstate-v2"
         );
         let dirstate = self.dirstate_file_contents()?;
         if dirstate.is_empty() {
             self.dirstate_parents.set(DirstateParents::NULL);
             Ok(None)
         } else {
             let docket =
                 crate::dirstate_tree::on_disk::read_docket(&dirstate)?;
             self.dirstate_parents.set(docket.parents());
             Ok(Some(docket.uuid.to_owned()))
         }
     }
 
     fn new_dirstate_map(&self) -> Result<OwningDirstateMap, DirstateError> {
         let dirstate_file_contents = self.dirstate_file_contents()?;
         if dirstate_file_contents.is_empty() {
             self.dirstate_parents.set(DirstateParents::NULL);
             if self.has_dirstate_v2() {
                 self.dirstate_data_file_uuid.set(None);
             }
             Ok(OwningDirstateMap::new_empty(Vec::new()))
         } else if self.has_dirstate_v2() {
             let docket = crate::dirstate_tree::on_disk::read_docket(
                 &dirstate_file_contents,
             )?;
             self.dirstate_parents.set(docket.parents());
             self.dirstate_data_file_uuid
                 .set(Some(docket.uuid.to_owned()));
             let data_size = docket.data_size();
             let metadata = docket.tree_metadata();
             if let Some(data_mmap) = self
                 .hg_vfs()
                 .mmap_open(docket.data_filename())
                 .io_not_found_as_none()?
             {
                 OwningDirstateMap::new_v2(data_mmap, data_size, metadata)
             } else {
                 OwningDirstateMap::new_v2(Vec::new(), data_size, metadata)
             }
         } else {
             let (map, parents) =
                 OwningDirstateMap::new_v1(dirstate_file_contents)?;
             self.dirstate_parents.set(parents);
             Ok(map)
         }
     }
 
     pub fn dirstate_map(
         &self,
     ) -> Result<Ref<OwningDirstateMap>, DirstateError> {
         self.dirstate_map.get_or_init(|| self.new_dirstate_map())
     }
 
     pub fn dirstate_map_mut(
         &self,
     ) -> Result<RefMut<OwningDirstateMap>, DirstateError> {
         self.dirstate_map
             .get_mut_or_init(|| self.new_dirstate_map())
     }
 
     fn new_changelog(&self) -> Result<Changelog, HgError> {
         Changelog::open(&self.store_vfs(), self.has_nodemap())
     }
 
     pub fn changelog(&self) -> Result<Ref<Changelog>, HgError> {
         self.changelog.get_or_init(|| self.new_changelog())
     }
 
     pub fn changelog_mut(&self) -> Result<RefMut<Changelog>, HgError> {
         self.changelog.get_mut_or_init(|| self.new_changelog())
     }
 
     fn new_manifestlog(&self) -> Result<Manifestlog, HgError> {
         Manifestlog::open(&self.store_vfs(), self.has_nodemap())
     }
 
     pub fn manifestlog(&self) -> Result<Ref<Manifestlog>, HgError> {
         self.manifestlog.get_or_init(|| self.new_manifestlog())
     }
 
     pub fn manifestlog_mut(&self) -> Result<RefMut<Manifestlog>, HgError> {
         self.manifestlog.get_mut_or_init(|| self.new_manifestlog())
     }
 
     /// Returns the manifest of the *changeset* with the given node ID
     pub fn manifest_for_node(
         &self,
         node: impl Into<NodePrefix>,
     ) -> Result<Manifest, RevlogError> {
         self.manifestlog()?.data_for_node(
             self.changelog()?
                 .data_for_node(node.into())?
                 .manifest_node()?
                 .into(),
         )
     }
 
     /// Returns the manifest of the *changeset* with the given revision number
     pub fn manifest_for_rev(
         &self,
         revision: Revision,
     ) -> Result<Manifest, RevlogError> {
         self.manifestlog()?.data_for_node(
             self.changelog()?
                 .data_for_rev(revision)?
                 .manifest_node()?
                 .into(),
         )
     }
 
     pub fn has_subrepos(&self) -> Result<bool, DirstateError> {
         if let Some(entry) = self.dirstate_map()?.get(HgPath::new(".hgsub"))? {
             Ok(entry.tracked())
         } else {
             Ok(false)
         }
     }
 
     pub fn filelog(&self, path: &HgPath) -> Result<Filelog, HgError> {
         Filelog::open(self, path)
     }
 
     /// Write to disk any updates that were made through `dirstate_map_mut`.
     ///
     /// The "wlock" must be held while calling this.
     /// See for example `try_with_wlock_no_wait`.
     ///
     /// TODO: have a `WritableRepo` type only accessible while holding the
     /// lock?
     pub fn write_dirstate(&self) -> Result<(), DirstateError> {
         let map = self.dirstate_map()?;
         // TODO: Maintain a `DirstateMap::dirty` flag, and return early here if
         // it’s unset
         let parents = self.dirstate_parents()?;
         let (packed_dirstate, old_uuid_to_remove) = if self.has_dirstate_v2() {
             let uuid_opt = self
                 .dirstate_data_file_uuid
                 .get_or_init(|| self.read_dirstate_data_file_uuid())?;
             let uuid_opt = uuid_opt.as_ref();
             let can_append = uuid_opt.is_some();
             let (data, tree_metadata, append, old_data_size) =
                 map.pack_v2(can_append)?;
 
             // Reuse the uuid, or generate a new one, keeping the old for
             // deletion.
             let (uuid, old_uuid) = match uuid_opt {
                 Some(uuid) => {
                     let as_str = std::str::from_utf8(uuid)
                         .map_err(|_| {
                             HgError::corrupted(
                                 "non-UTF-8 dirstate data file ID",
                             )
                         })?
                         .to_owned();
                     if append {
                         (as_str, None)
                     } else {
                         (DirstateDocket::new_uid(), Some(as_str))
                     }
                 }
                 None => (DirstateDocket::new_uid(), None),
             };
 
             let data_filename = format!("dirstate.{}", uuid);
             let data_filename = self.hg_vfs().join(data_filename);
             let mut options = std::fs::OpenOptions::new();
             options.write(true);
 
             // Why are we not using the O_APPEND flag when appending?
             //
             // - O_APPEND makes it trickier to deal with garbage at the end of
             //   the file, left by a previous uncommitted transaction. By
             //   starting the write at [old_data_size] we make sure we erase
             //   all such garbage.
             //
             // - O_APPEND requires to special-case 0-byte writes, whereas we
             //   don't need that.
             //
             // - Some OSes have bugs in implementation O_APPEND:
             //   revlog.py talks about a Solaris bug, but we also saw some ZFS
             //   bug: https://github.com/openzfs/zfs/pull/3124,
             //   https://github.com/openzfs/zfs/issues/13370
             //
             if !append {
                 options.create_new(true);
             }
 
             let data_size = (|| {
                 // TODO: loop and try another random ID if !append and this
                 // returns `ErrorKind::AlreadyExists`? Collision chance of two
                 // random IDs is one in 2**32
                 let mut file = options.open(&data_filename)?;
                 if append {
                     file.seek(SeekFrom::Start(old_data_size as u64))?;
                 }
                 file.write_all(&data)?;
                 file.flush()?;
                 file.seek(SeekFrom::Current(0))
             })()
             .when_writing_file(&data_filename)?;
 
             let packed_dirstate = DirstateDocket::serialize(
                 parents,
                 tree_metadata,
                 data_size,
                 uuid.as_bytes(),
             )
             .map_err(|_: std::num::TryFromIntError| {
                 HgError::corrupted("overflow in dirstate docket serialization")
             })?;
 
             (packed_dirstate, old_uuid)
         } else {
             (map.pack_v1(parents)?, None)
         };
 
         let vfs = self.hg_vfs();
         vfs.atomic_write("dirstate", &packed_dirstate)?;
         if let Some(uuid) = old_uuid_to_remove {
             // Remove the old data file after the new docket pointing to the
             // new data file was written.
             vfs.remove_file(format!("dirstate.{}", uuid))?;
         }
         Ok(())
     }
 }
 
 /// Lazily-initialized component of `Repo` with interior mutability
 ///
 /// This differs from `OnceCell` in that the value can still be "deinitialized"
 /// later by setting its inner `Option` to `None`. It also takes the
 /// initialization function as an argument when the value is requested, not
 /// when the instance is created.
 struct LazyCell<T> {
     value: RefCell<Option<T>>,
 }
 
 impl<T> LazyCell<T> {
     fn new() -> Self {
         Self {
             value: RefCell::new(None),
         }
     }
 
     fn set(&self, value: T) {
         *self.value.borrow_mut() = Some(value)
     }
 
     fn get_or_init<E>(
         &self,
         init: impl Fn() -> Result<T, E>,
     ) -> Result<Ref<T>, E> {
         let mut borrowed = self.value.borrow();
         if borrowed.is_none() {
             drop(borrowed);
             // Only use `borrow_mut` if it is really needed to avoid panic in
             // case there is another outstanding borrow but mutation is not
             // needed.
             *self.value.borrow_mut() = Some(init()?);
             borrowed = self.value.borrow()
         }
         Ok(Ref::map(borrowed, |option| option.as_ref().unwrap()))
     }
 
     fn get_mut_or_init<E>(
         &self,
         init: impl Fn() -> Result<T, E>,
     ) -> Result<RefMut<T>, E> {
         let mut borrowed = self.value.borrow_mut();
         if borrowed.is_none() {
             *borrowed = Some(init()?);
         }
         Ok(RefMut::map(borrowed, |option| option.as_mut().unwrap()))
     }
 }

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

@@ -1,271 +1,271 b''
 use crate::errors::HgError;
 use crate::revlog::revlog::{Revlog, RevlogEntry, RevlogError};
 use crate::revlog::Revision;
 use crate::revlog::{Node, NodePrefix};
 use crate::utils::hg_path::HgPath;
 use crate::vfs::Vfs;
 use itertools::Itertools;
 use std::ascii::escape_default;
 use std::borrow::Cow;
 use std::fmt::{Debug, Formatter};
 
 /// A specialized `Revlog` to work with `changelog` data format.
 pub struct Changelog {
     /// The generic `revlog` format.
     pub(crate) revlog: Revlog,
 }
 
 impl Changelog {
     /// Open the `changelog` of a repository given by its root.
     pub fn open(store_vfs: &Vfs, use_nodemap: bool) -> Result<Self, HgError> {
         let revlog =
             Revlog::open(store_vfs, "00changelog.i", None, use_nodemap)?;
         Ok(Self { revlog })
     }
 
     /// Return the `ChangelogEntry` for the given node ID.
     pub fn data_for_node(
         &self,
         node: NodePrefix,
     ) -> Result<ChangelogRevisionData, RevlogError> {
         let rev = self.revlog.rev_from_node(node)?;
         self.data_for_rev(rev)
     }
 
     /// Return the `RevlogEntry` of the given revision number.
     pub fn entry_for_rev(
         &self,
         rev: Revision,
     ) -> Result<RevlogEntry, RevlogError> {
         self.revlog.get_entry(rev)
     }
 
     /// Return the `ChangelogEntry` of the given revision number.
     pub fn data_for_rev(
         &self,
         rev: Revision,
     ) -> Result<ChangelogRevisionData, RevlogError> {
         let bytes = self.revlog.get_rev_data(rev)?;
         if bytes.is_empty() {
             Ok(ChangelogRevisionData::null())
         } else {
             Ok(ChangelogRevisionData::new(bytes).map_err(|err| {
                 RevlogError::Other(HgError::CorruptedRepository(format!(
                     "Invalid changelog data for revision {}: {:?}",
                     rev, err
                 )))
             })?)
         }
     }
 
     pub fn node_from_rev(&self, rev: Revision) -> Option<&Node> {
         self.revlog.node_from_rev(rev)
     }
 
     pub fn rev_from_node(
         &self,
         node: NodePrefix,
     ) -> Result<Revision, RevlogError> {
         self.revlog.rev_from_node(node)
     }
 }
 
 /// `Changelog` entry which knows how to interpret the `changelog` data bytes.
 #[derive(PartialEq)]
 pub struct ChangelogRevisionData<'changelog> {
     /// The data bytes of the `changelog` entry.
     bytes: Cow<'changelog, [u8]>,
     /// The end offset for the hex manifest (not including the newline)
     manifest_end: usize,
     /// The end offset for the user+email (not including the newline)
     user_end: usize,
     /// The end offset for the timestamp+timezone+extras (not including the
     /// newline)
     timestamp_end: usize,
     /// The end offset for the file list (not including the newline)
     files_end: usize,
 }
 
 impl<'changelog> ChangelogRevisionData<'changelog> {
     fn new(bytes: Cow<'changelog, [u8]>) -> Result<Self, HgError> {
         let mut line_iter = bytes.split(|b| b == &b'\n');
         let manifest_end = line_iter
             .next()
             .expect("Empty iterator from split()?")
             .len();
         let user_slice = line_iter.next().ok_or_else(|| {
             HgError::corrupted("Changeset data truncated after manifest line")
         })?;
         let user_end = manifest_end + 1 + user_slice.len();
         let timestamp_slice = line_iter.next().ok_or_else(|| {
             HgError::corrupted("Changeset data truncated after user line")
         })?;
         let timestamp_end = user_end + 1 + timestamp_slice.len();
         let mut files_end = timestamp_end + 1;
         loop {
             let line = line_iter.next().ok_or_else(|| {
                 HgError::corrupted("Changeset data truncated in files list")
             })?;
             if line.is_empty() {
                 if files_end == bytes.len() {
                     // The list of files ended with a single newline (there
                     // should be two)
                     return Err(HgError::corrupted(
                         "Changeset data truncated after files list",
                     ));
                 }
                 files_end -= 1;
                 break;
             }
             files_end += line.len() + 1;
         }
 
         Ok(Self {
             bytes,
             manifest_end,
             user_end,
             timestamp_end,
             files_end,
         })
     }
 
     fn null() -> Self {
         Self::new(Cow::Borrowed(
             b"0000000000000000000000000000000000000000\n\n0 0\n\n",
         ))
         .unwrap()
     }
 
     /// Return an iterator over the lines of the entry.
     pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
         self.bytes.split(|b| b == &b'\n')
     }
 
     /// Return the node id of the `manifest` referenced by this `changelog`
     /// entry.
     pub fn manifest_node(&self) -> Result<Node, HgError> {
         let manifest_node_hex = &self.bytes[..self.manifest_end];
         Node::from_hex_for_repo(manifest_node_hex)
     }
 
     /// The full user string (usually a name followed by an email enclosed in
     /// angle brackets)
     pub fn user(&self) -> &[u8] {
         &self.bytes[self.manifest_end + 1..self.user_end]
     }
 
     /// The full timestamp line (timestamp in seconds, offset in seconds, and
     /// possibly extras)
     // TODO: We should expose this in a more useful way
     pub fn timestamp_line(&self) -> &[u8] {
         &self.bytes[self.user_end + 1..self.timestamp_end]
     }
 
     /// The files changed in this revision.
     pub fn files(&self) -> impl Iterator<Item = &HgPath> {
         self.bytes[self.timestamp_end + 1..self.files_end]
             .split(|b| b == &b'\n')
-            .map(|path| HgPath::new(path))
+            .map(HgPath::new)
     }
 
     /// The change description.
     pub fn description(&self) -> &[u8] {
         &self.bytes[self.files_end + 2..]
     }
 }
 
 impl Debug for ChangelogRevisionData<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("ChangelogRevisionData")
             .field("bytes", &debug_bytes(&self.bytes))
             .field("manifest", &debug_bytes(&self.bytes[..self.manifest_end]))
             .field(
                 "user",
                 &debug_bytes(
                     &self.bytes[self.manifest_end + 1..self.user_end],
                 ),
             )
             .field(
                 "timestamp",
                 &debug_bytes(
                     &self.bytes[self.user_end + 1..self.timestamp_end],
                 ),
             )
             .field(
                 "files",
                 &debug_bytes(
                     &self.bytes[self.timestamp_end + 1..self.files_end],
                 ),
             )
             .field(
                 "description",
                 &debug_bytes(&self.bytes[self.files_end + 2..]),
             )
             .finish()
     }
 }
 
 fn debug_bytes(bytes: &[u8]) -> String {
     String::from_utf8_lossy(
         &bytes.iter().flat_map(|b| escape_default(*b)).collect_vec(),
     )
     .to_string()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
     #[test]
     fn test_create_changelogrevisiondata_invalid() {
         // Completely empty
         assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd")).is_err());
         // No newline after manifest
         assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd")).is_err());
         // No newline after user
         assert!(ChangelogRevisionData::new(Cow::Borrowed(b"abcd\n")).is_err());
         // No newline after timestamp
         assert!(
             ChangelogRevisionData::new(Cow::Borrowed(b"abcd\n\n0 0")).is_err()
         );
         // Missing newline after files
         assert!(ChangelogRevisionData::new(Cow::Borrowed(
             b"abcd\n\n0 0\nfile1\nfile2"
         ))
         .is_err(),);
         // Only one newline after files
         assert!(ChangelogRevisionData::new(Cow::Borrowed(
             b"abcd\n\n0 0\nfile1\nfile2\n"
         ))
         .is_err(),);
     }
 
     #[test]
     fn test_create_changelogrevisiondata() {
         let data = ChangelogRevisionData::new(Cow::Borrowed(
             b"0123456789abcdef0123456789abcdef01234567
 Some One <[e-mail]>
 0 0
 file1
 file2
 
 some
 commit
 message",
         ))
         .unwrap();
         assert_eq!(
             data.manifest_node().unwrap(),
             Node::from_hex("0123456789abcdef0123456789abcdef01234567")
                 .unwrap()
         );
         assert_eq!(data.user(), b"Some One <[e-mail]>");
         assert_eq!(data.timestamp_line(), b"0 0");
         assert_eq!(
             data.files().collect_vec(),
             vec![HgPath::new("file1"), HgPath::new("file2")]
         );
         assert_eq!(data.description(), b"some\ncommit\nmessage");
     }
 }

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

@@ -1,208 +1,208 b''
 use crate::errors::HgError;
 use crate::repo::Repo;
 use crate::revlog::path_encode::path_encode;
 use crate::revlog::revlog::RevlogEntry;
 use crate::revlog::revlog::{Revlog, RevlogError};
 use crate::revlog::NodePrefix;
 use crate::revlog::Revision;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::HgPath;
 use crate::utils::SliceExt;
 use std::path::PathBuf;
 
 /// A specialized `Revlog` to work with file data logs.
 pub struct Filelog {
     /// The generic `revlog` format.
     revlog: Revlog,
 }
 
 impl Filelog {
     pub fn open_vfs(
         store_vfs: &crate::vfs::Vfs<'_>,
         file_path: &HgPath,
     ) -> Result<Self, HgError> {
         let index_path = store_path(file_path, b".i");
         let data_path = store_path(file_path, b".d");
         let revlog =
             Revlog::open(store_vfs, index_path, Some(&data_path), false)?;
         Ok(Self { revlog })
     }
 
     pub fn open(repo: &Repo, file_path: &HgPath) -> Result<Self, HgError> {
         Self::open_vfs(&repo.store_vfs(), file_path)
     }
 
     /// The given node ID is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn data_for_node(
         &self,
         file_node: impl Into<NodePrefix>,
     ) -> Result<FilelogRevisionData, RevlogError> {
         let file_rev = self.revlog.rev_from_node(file_node.into())?;
         self.data_for_rev(file_rev)
     }
 
     /// The given revision is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn data_for_rev(
         &self,
         file_rev: Revision,
     ) -> Result<FilelogRevisionData, RevlogError> {
         let data: Vec<u8> = self.revlog.get_rev_data(file_rev)?.into_owned();
-        Ok(FilelogRevisionData(data.into()))
+        Ok(FilelogRevisionData(data))
     }
 
     /// The given node ID is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn entry_for_node(
         &self,
         file_node: impl Into<NodePrefix>,
     ) -> Result<FilelogEntry, RevlogError> {
         let file_rev = self.revlog.rev_from_node(file_node.into())?;
         self.entry_for_rev(file_rev)
     }
 
     /// The given revision is that of the file as found in a filelog, not of a
     /// changeset.
     pub fn entry_for_rev(
         &self,
         file_rev: Revision,
     ) -> Result<FilelogEntry, RevlogError> {
         Ok(FilelogEntry(self.revlog.get_entry(file_rev)?))
     }
 }
 
 fn store_path(hg_path: &HgPath, suffix: &[u8]) -> PathBuf {
     let encoded_bytes =
         path_encode(&[b"data/", hg_path.as_bytes(), suffix].concat());
     get_path_from_bytes(&encoded_bytes).into()
 }
 
 pub struct FilelogEntry<'a>(RevlogEntry<'a>);
 
 impl FilelogEntry<'_> {
     /// `self.data()` can be expensive, with decompression and delta
     /// resolution.
     ///
     /// *Without* paying this cost, based on revlog index information
     /// including `RevlogEntry::uncompressed_len`:
     ///
     /// * Returns `true` if the length that `self.data().file_data().len()`
     ///   would return is definitely **not equal** to `other_len`.
     /// * Returns `false` if available information is inconclusive.
     pub fn file_data_len_not_equal_to(&self, other_len: u64) -> bool {
         // Relevant code that implement this behavior in Python code:
         // basefilectx.cmp, filelog.size, storageutil.filerevisioncopied,
         // revlog.size, revlog.rawsize
 
         // Let’s call `file_data_len` what would be returned by
         // `self.data().file_data().len()`.
 
         if self.0.is_censored() {
             let file_data_len = 0;
             return other_len != file_data_len;
         }
 
         if self.0.has_length_affecting_flag_processor() {
             // We can’t conclude anything about `file_data_len`.
             return false;
         }
 
         // Revlog revisions (usually) have metadata for the size of
         // their data after decompression and delta resolution
         // as would be returned by `Revlog::get_rev_data`.
         //
         // For filelogs this is the file’s contents preceded by an optional
         // metadata block.
         let uncompressed_len = if let Some(l) = self.0.uncompressed_len() {
             l as u64
         } else {
             // The field was set to -1, the actual uncompressed len is unknown.
             // We need to decompress to say more.
             return false;
         };
         // `uncompressed_len = file_data_len + optional_metadata_len`,
         // so `file_data_len <= uncompressed_len`.
         if uncompressed_len < other_len {
             // Transitively, `file_data_len < other_len`.
             // So `other_len != file_data_len` definitely.
             return true;
         }
 
         if uncompressed_len == other_len + 4 {
             // It’s possible that `file_data_len == other_len` with an empty
             // metadata block (2 start marker bytes + 2 end marker bytes).
             // This happens when there wouldn’t otherwise be metadata, but
             // the first 2 bytes of file data happen to match a start marker
             // and would be ambiguous.
             return false;
         }
 
         if !self.0.has_p1() {
             // There may or may not be copy metadata, so we can’t deduce more
             // about `file_data_len` without computing file data.
             return false;
         }
 
         // Filelog ancestry is not meaningful in the way changelog ancestry is.
         // It only provides hints to delta generation.
         // p1 and p2 are set to null when making a copy or rename since
         // contents are likely unrelatedto what might have previously existed
         // at the destination path.
         //
         // Conversely, since here p1 is non-null, there is no copy metadata.
         // Note that this reasoning may be invalidated in the presence of
         // merges made by some previous versions of Mercurial that
         // swapped p1 and p2. See <https://bz.mercurial-scm.org/show_bug.cgi?id=6528>
         // and `tests/test-issue6528.t`.
         //
         // Since copy metadata is currently the only kind of metadata
         // kept in revlog data of filelogs,
         // this `FilelogEntry` does not have such metadata:
         let file_data_len = uncompressed_len;
 
-        return file_data_len != other_len;
+        file_data_len != other_len
     }
 
     pub fn data(&self) -> Result<FilelogRevisionData, HgError> {
         Ok(FilelogRevisionData(self.0.data()?.into_owned()))
     }
 }
 
 /// The data for one revision in a filelog, uncompressed and delta-resolved.
 pub struct FilelogRevisionData(Vec<u8>);
 
 impl FilelogRevisionData {
     /// Split into metadata and data
     pub fn split(&self) -> Result<(Option<&[u8]>, &[u8]), HgError> {
         const DELIMITER: &[u8; 2] = &[b'\x01', b'\n'];
 
         if let Some(rest) = self.0.drop_prefix(DELIMITER) {
             if let Some((metadata, data)) = rest.split_2_by_slice(DELIMITER) {
                 Ok((Some(metadata), data))
             } else {
                 Err(HgError::corrupted(
                     "Missing metadata end delimiter in filelog entry",
                 ))
             }
         } else {
             Ok((None, &self.0))
         }
     }
 
     /// Returns the file contents at this revision, stripped of any metadata
     pub fn file_data(&self) -> Result<&[u8], HgError> {
         let (_metadata, data) = self.split()?;
         Ok(data)
     }
 
     /// Consume the entry, and convert it into data, discarding any metadata,
     /// if present.
     pub fn into_file_data(self) -> Result<Vec<u8>, HgError> {
         if let (Some(_metadata), data) = self.split()? {
             Ok(data.to_owned())
         } else {
             Ok(self.0)
         }
     }
 }

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

@@ -1,616 +1,615 b''
 use std::ops::Deref;
 
 use byteorder::{BigEndian, ByteOrder};
 
 use crate::errors::HgError;
 use crate::revlog::node::Node;
 use crate::revlog::{Revision, NULL_REVISION};
 
 pub const INDEX_ENTRY_SIZE: usize = 64;
 
 pub struct IndexHeader {
     header_bytes: [u8; 4],
 }
 
 #[derive(Copy, Clone)]
 pub struct IndexHeaderFlags {
     flags: u16,
 }
 
 /// Corresponds to the high bits of `_format_flags` in python
 impl IndexHeaderFlags {
     /// Corresponds to FLAG_INLINE_DATA in python
     pub fn is_inline(self) -> bool {
-        return self.flags & 1 != 0;
+        self.flags & 1 != 0
     }
     /// Corresponds to FLAG_GENERALDELTA in python
     pub fn uses_generaldelta(self) -> bool {
-        return self.flags & 2 != 0;
+        self.flags & 2 != 0
     }
 }
 
 /// Corresponds to the INDEX_HEADER structure,
 /// which is parsed as a `header` variable in `_loadindex` in `revlog.py`
 impl IndexHeader {
     fn format_flags(&self) -> IndexHeaderFlags {
         // No "unknown flags" check here, unlike in python. Maybe there should
         // be.
-        return IndexHeaderFlags {
+        IndexHeaderFlags {
             flags: BigEndian::read_u16(&self.header_bytes[0..2]),
-        };
+        }
     }
 
     /// The only revlog version currently supported by rhg.
     const REVLOGV1: u16 = 1;
 
     /// Corresponds to `_format_version` in Python.
     fn format_version(&self) -> u16 {
-        return BigEndian::read_u16(&self.header_bytes[2..4]);
+        BigEndian::read_u16(&self.header_bytes[2..4])
     }
 
     const EMPTY_INDEX_HEADER: IndexHeader = IndexHeader {
         // We treat an empty file as a valid index with no entries.
         // Here we make an arbitrary choice of what we assume the format of the
         // index to be (V1, using generaldelta).
         // This doesn't matter too much, since we're only doing read-only
         // access. but the value corresponds to the `new_header` variable in
         // `revlog.py`, `_loadindex`
         header_bytes: [0, 3, 0, 1],
     };
 
     fn parse(index_bytes: &[u8]) -> Result<IndexHeader, HgError> {
-        if index_bytes.len() == 0 {
+        if index_bytes.is_empty() {
             return Ok(IndexHeader::EMPTY_INDEX_HEADER);
         }
         if index_bytes.len() < 4 {
             return Err(HgError::corrupted(
                 "corrupted revlog: can't read the index format header",
             ));
         }
-        return Ok(IndexHeader {
+        Ok(IndexHeader {
             header_bytes: {
                 let bytes: [u8; 4] =
                     index_bytes[0..4].try_into().expect("impossible");
                 bytes
             },
-        });
+        })
     }
 }
 
 /// A Revlog index
 pub struct Index {
     bytes: Box<dyn Deref<Target = [u8]> + Send>,
     /// Offsets of starts of index blocks.
     /// Only needed when the index is interleaved with data.
     offsets: Option<Vec<usize>>,
     uses_generaldelta: bool,
 }
 
 impl Index {
     /// Create an index from bytes.
     /// Calculate the start of each entry when is_inline is true.
     pub fn new(
         bytes: Box<dyn Deref<Target = [u8]> + Send>,
     ) -> Result<Self, HgError> {
         let header = IndexHeader::parse(bytes.as_ref())?;
 
         if header.format_version() != IndexHeader::REVLOGV1 {
             // A proper new version should have had a repo/store
             // requirement.
             return Err(HgError::corrupted("unsupported revlog version"));
         }
 
         // This is only correct because we know version is REVLOGV1.
         // In v2 we always use generaldelta, while in v0 we never use
         // generaldelta. Similar for [is_inline] (it's only used in v1).
         let uses_generaldelta = header.format_flags().uses_generaldelta();
 
         if header.format_flags().is_inline() {
             let mut offset: usize = 0;
             let mut offsets = Vec::new();
 
             while offset + INDEX_ENTRY_SIZE <= bytes.len() {
                 offsets.push(offset);
                 let end = offset + INDEX_ENTRY_SIZE;
                 let entry = IndexEntry {
                     bytes: &bytes[offset..end],
                     offset_override: None,
                 };
 
                 offset += INDEX_ENTRY_SIZE + entry.compressed_len() as usize;
             }
 
             if offset == bytes.len() {
                 Ok(Self {
                     bytes,
                     offsets: Some(offsets),
                     uses_generaldelta,
                 })
             } else {
-                Err(HgError::corrupted("unexpected inline revlog length")
-                    .into())
+                Err(HgError::corrupted("unexpected inline revlog length"))
             }
         } else {
             Ok(Self {
                 bytes,
                 offsets: None,
                 uses_generaldelta,
             })
         }
     }
 
     pub fn uses_generaldelta(&self) -> bool {
         self.uses_generaldelta
     }
 
     /// Value of the inline flag.
     pub fn is_inline(&self) -> bool {
         self.offsets.is_some()
     }
 
     /// Return a slice of bytes if `revlog` is inline. Panic if not.
     pub fn data(&self, start: usize, end: usize) -> &[u8] {
         if !self.is_inline() {
             panic!("tried to access data in the index of a revlog that is not inline");
         }
         &self.bytes[start..end]
     }
 
     /// Return number of entries of the revlog index.
     pub fn len(&self) -> usize {
         if let Some(offsets) = &self.offsets {
             offsets.len()
         } else {
             self.bytes.len() / INDEX_ENTRY_SIZE
         }
     }
 
     /// Returns `true` if the `Index` has zero `entries`.
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
 
     /// Return the index entry corresponding to the given revision if it
     /// exists.
     pub fn get_entry(&self, rev: Revision) -> Option<IndexEntry> {
         if rev == NULL_REVISION {
             return None;
         }
         if let Some(offsets) = &self.offsets {
             self.get_entry_inline(rev, offsets)
         } else {
             self.get_entry_separated(rev)
         }
     }
 
     fn get_entry_inline(
         &self,
         rev: Revision,
         offsets: &[usize],
     ) -> Option<IndexEntry> {
         let start = *offsets.get(rev as usize)?;
         let end = start.checked_add(INDEX_ENTRY_SIZE)?;
         let bytes = &self.bytes[start..end];
 
         // See IndexEntry for an explanation of this override.
         let offset_override = Some(end);
 
         Some(IndexEntry {
             bytes,
             offset_override,
         })
     }
 
     fn get_entry_separated(&self, rev: Revision) -> Option<IndexEntry> {
         let max_rev = self.bytes.len() / INDEX_ENTRY_SIZE;
         if rev as usize >= max_rev {
             return None;
         }
         let start = rev as usize * INDEX_ENTRY_SIZE;
         let end = start + INDEX_ENTRY_SIZE;
         let bytes = &self.bytes[start..end];
 
         // Override the offset of the first revision as its bytes are used
         // for the index's metadata (saving space because it is always 0)
         let offset_override = if rev == 0 { Some(0) } else { None };
 
         Some(IndexEntry {
             bytes,
             offset_override,
         })
     }
 }
 
 impl super::RevlogIndex for Index {
     fn len(&self) -> usize {
         self.len()
     }
 
     fn node(&self, rev: Revision) -> Option<&Node> {
         self.get_entry(rev).map(|entry| entry.hash())
     }
 }
 
 #[derive(Debug)]
 pub struct IndexEntry<'a> {
     bytes: &'a [u8],
     /// Allows to override the offset value of the entry.
     ///
     /// For interleaved index and data, the offset stored in the index
     /// corresponds to the separated data offset.
     /// It has to be overridden with the actual offset in the interleaved
     /// index which is just after the index block.
     ///
     /// For separated index and data, the offset stored in the first index
     /// entry is mixed with the index headers.
     /// It has to be overridden with 0.
     offset_override: Option<usize>,
 }
 
 impl<'a> IndexEntry<'a> {
     /// Return the offset of the data.
     pub fn offset(&self) -> usize {
         if let Some(offset_override) = self.offset_override {
             offset_override
         } else {
             let mut bytes = [0; 8];
             bytes[2..8].copy_from_slice(&self.bytes[0..=5]);
             BigEndian::read_u64(&bytes[..]) as usize
         }
     }
 
     pub fn flags(&self) -> u16 {
         BigEndian::read_u16(&self.bytes[6..=7])
     }
 
     /// Return the compressed length of the data.
     pub fn compressed_len(&self) -> u32 {
         BigEndian::read_u32(&self.bytes[8..=11])
     }
 
     /// Return the uncompressed length of the data.
     pub fn uncompressed_len(&self) -> i32 {
         BigEndian::read_i32(&self.bytes[12..=15])
     }
 
     /// Return the revision upon which the data has been derived.
     pub fn base_revision_or_base_of_delta_chain(&self) -> Revision {
         // TODO Maybe return an Option when base_revision == rev?
         //      Requires to add rev to IndexEntry
 
         BigEndian::read_i32(&self.bytes[16..])
     }
 
     pub fn link_revision(&self) -> Revision {
         BigEndian::read_i32(&self.bytes[20..])
     }
 
     pub fn p1(&self) -> Revision {
         BigEndian::read_i32(&self.bytes[24..])
     }
 
     pub fn p2(&self) -> Revision {
         BigEndian::read_i32(&self.bytes[28..])
     }
 
     /// Return the hash of revision's full text.
     ///
     /// Currently, SHA-1 is used and only the first 20 bytes of this field
     /// are used.
     pub fn hash(&self) -> &'a Node {
         (&self.bytes[32..52]).try_into().unwrap()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::node::NULL_NODE;
 
     #[cfg(test)]
     #[derive(Debug, Copy, Clone)]
     pub struct IndexEntryBuilder {
         is_first: bool,
         is_inline: bool,
         is_general_delta: bool,
         version: u16,
         offset: usize,
         compressed_len: usize,
         uncompressed_len: usize,
         base_revision_or_base_of_delta_chain: Revision,
         link_revision: Revision,
         p1: Revision,
         p2: Revision,
         node: Node,
     }
 
     #[cfg(test)]
     impl IndexEntryBuilder {
         #[allow(clippy::new_without_default)]
         pub fn new() -> Self {
             Self {
                 is_first: false,
                 is_inline: false,
                 is_general_delta: true,
                 version: 1,
                 offset: 0,
                 compressed_len: 0,
                 uncompressed_len: 0,
                 base_revision_or_base_of_delta_chain: 0,
                 link_revision: 0,
                 p1: NULL_REVISION,
                 p2: NULL_REVISION,
                 node: NULL_NODE,
             }
         }
 
         pub fn is_first(&mut self, value: bool) -> &mut Self {
             self.is_first = value;
             self
         }
 
         pub fn with_inline(&mut self, value: bool) -> &mut Self {
             self.is_inline = value;
             self
         }
 
         pub fn with_general_delta(&mut self, value: bool) -> &mut Self {
             self.is_general_delta = value;
             self
         }
 
         pub fn with_version(&mut self, value: u16) -> &mut Self {
             self.version = value;
             self
         }
 
         pub fn with_offset(&mut self, value: usize) -> &mut Self {
             self.offset = value;
             self
         }
 
         pub fn with_compressed_len(&mut self, value: usize) -> &mut Self {
             self.compressed_len = value;
             self
         }
 
         pub fn with_uncompressed_len(&mut self, value: usize) -> &mut Self {
             self.uncompressed_len = value;
             self
         }
 
         pub fn with_base_revision_or_base_of_delta_chain(
             &mut self,
             value: Revision,
         ) -> &mut Self {
             self.base_revision_or_base_of_delta_chain = value;
             self
         }
 
         pub fn with_link_revision(&mut self, value: Revision) -> &mut Self {
             self.link_revision = value;
             self
         }
 
         pub fn with_p1(&mut self, value: Revision) -> &mut Self {
             self.p1 = value;
             self
         }
 
         pub fn with_p2(&mut self, value: Revision) -> &mut Self {
             self.p2 = value;
             self
         }
 
         pub fn with_node(&mut self, value: Node) -> &mut Self {
             self.node = value;
             self
         }
 
         pub fn build(&self) -> Vec<u8> {
             let mut bytes = Vec::with_capacity(INDEX_ENTRY_SIZE);
             if self.is_first {
                 bytes.extend(&match (self.is_general_delta, self.is_inline) {
                     (false, false) => [0u8, 0],
                     (false, true) => [0u8, 1],
                     (true, false) => [0u8, 2],
                     (true, true) => [0u8, 3],
                 });
                 bytes.extend(&self.version.to_be_bytes());
                 // Remaining offset bytes.
                 bytes.extend(&[0u8; 2]);
             } else {
                 // Offset stored on 48 bits (6 bytes)
                 bytes.extend(&(self.offset as u64).to_be_bytes()[2..]);
             }
             bytes.extend(&[0u8; 2]); // Revision flags.
             bytes.extend(&(self.compressed_len as u32).to_be_bytes());
             bytes.extend(&(self.uncompressed_len as u32).to_be_bytes());
             bytes.extend(
                 &self.base_revision_or_base_of_delta_chain.to_be_bytes(),
             );
             bytes.extend(&self.link_revision.to_be_bytes());
             bytes.extend(&self.p1.to_be_bytes());
             bytes.extend(&self.p2.to_be_bytes());
             bytes.extend(self.node.as_bytes());
             bytes.extend(vec![0u8; 12]);
             bytes
         }
     }
 
     pub fn is_inline(index_bytes: &[u8]) -> bool {
         IndexHeader::parse(index_bytes)
             .expect("too short")
             .format_flags()
             .is_inline()
     }
 
     pub fn uses_generaldelta(index_bytes: &[u8]) -> bool {
         IndexHeader::parse(index_bytes)
             .expect("too short")
             .format_flags()
             .uses_generaldelta()
     }
 
     pub fn get_version(index_bytes: &[u8]) -> u16 {
         IndexHeader::parse(index_bytes)
             .expect("too short")
             .format_version()
     }
 
     #[test]
     fn flags_when_no_inline_flag_test() {
         let bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_general_delta(false)
             .with_inline(false)
             .build();
 
-        assert_eq!(is_inline(&bytes), false);
-        assert_eq!(uses_generaldelta(&bytes), false);
+        assert!(!is_inline(&bytes));
+        assert!(!uses_generaldelta(&bytes));
     }
 
     #[test]
     fn flags_when_inline_flag_test() {
         let bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_general_delta(false)
             .with_inline(true)
             .build();
 
-        assert_eq!(is_inline(&bytes), true);
-        assert_eq!(uses_generaldelta(&bytes), false);
+        assert!(is_inline(&bytes));
+        assert!(!uses_generaldelta(&bytes));
     }
 
     #[test]
     fn flags_when_inline_and_generaldelta_flags_test() {
         let bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_general_delta(true)
             .with_inline(true)
             .build();
 
-        assert_eq!(is_inline(&bytes), true);
-        assert_eq!(uses_generaldelta(&bytes), true);
+        assert!(is_inline(&bytes));
+        assert!(uses_generaldelta(&bytes));
     }
 
     #[test]
     fn test_offset() {
         let bytes = IndexEntryBuilder::new().with_offset(1).build();
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(entry.offset(), 1)
     }
 
     #[test]
     fn test_with_overridden_offset() {
         let bytes = IndexEntryBuilder::new().with_offset(1).build();
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: Some(2),
         };
 
         assert_eq!(entry.offset(), 2)
     }
 
     #[test]
     fn test_compressed_len() {
         let bytes = IndexEntryBuilder::new().with_compressed_len(1).build();
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(entry.compressed_len(), 1)
     }
 
     #[test]
     fn test_uncompressed_len() {
         let bytes = IndexEntryBuilder::new().with_uncompressed_len(1).build();
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(entry.uncompressed_len(), 1)
     }
 
     #[test]
     fn test_base_revision_or_base_of_delta_chain() {
         let bytes = IndexEntryBuilder::new()
             .with_base_revision_or_base_of_delta_chain(1)
             .build();
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(entry.base_revision_or_base_of_delta_chain(), 1)
     }
 
     #[test]
     fn link_revision_test() {
         let bytes = IndexEntryBuilder::new().with_link_revision(123).build();
 
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(entry.link_revision(), 123);
     }
 
     #[test]
     fn p1_test() {
         let bytes = IndexEntryBuilder::new().with_p1(123).build();
 
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(entry.p1(), 123);
     }
 
     #[test]
     fn p2_test() {
         let bytes = IndexEntryBuilder::new().with_p2(123).build();
 
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(entry.p2(), 123);
     }
 
     #[test]
     fn node_test() {
         let node = Node::from_hex("0123456789012345678901234567890123456789")
             .unwrap();
         let bytes = IndexEntryBuilder::new().with_node(node).build();
 
         let entry = IndexEntry {
             bytes: &bytes,
             offset_override: None,
         };
 
         assert_eq!(*entry.hash(), node);
     }
 
     #[test]
     fn version_test() {
         let bytes = IndexEntryBuilder::new()
             .is_first(true)
             .with_version(2)
             .build();
 
         assert_eq!(get_version(&bytes), 2)
     }
 }
 
 #[cfg(test)]
 pub use tests::IndexEntryBuilder;

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

@@ -1,1069 +1,1069 b''
 // Copyright 2018-2020 Georges Racinet <[e-mail]>
 //           and Mercurial contributors
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 //! Indexing facilities for fast retrieval of `Revision` from `Node`
 //!
 //! This provides a variation on the 16-ary radix tree that is
 //! provided as "nodetree" in revlog.c, ready for append-only persistence
 //! on disk.
 //!
 //! Following existing implicit conventions, the "nodemap" terminology
 //! is used in a more abstract context.
 
 use super::{
     node::NULL_NODE, Node, NodePrefix, Revision, RevlogIndex, NULL_REVISION,
 };
 
 use bytes_cast::{unaligned, BytesCast};
 use std::cmp::max;
 use std::fmt;
 use std::mem::{self, align_of, size_of};
 use std::ops::Deref;
 use std::ops::Index;
 
 #[derive(Debug, PartialEq)]
 pub enum NodeMapError {
     MultipleResults,
     /// A `Revision` stored in the nodemap could not be found in the index
     RevisionNotInIndex(Revision),
 }
 
 /// Mapping system from Mercurial nodes to revision numbers.
 ///
 /// ## `RevlogIndex` and `NodeMap`
 ///
 /// One way to think about their relationship is that
 /// the `NodeMap` is a prefix-oriented reverse index of the `Node` information
 /// carried by a [`RevlogIndex`].
 ///
 /// Many of the methods in this trait take a `RevlogIndex` argument
 /// which is used for validation of their results. This index must naturally
 /// be the one the `NodeMap` is about, and it must be consistent.
 ///
 /// Notably, the `NodeMap` must not store
 /// information about more `Revision` values than there are in the index.
 /// In these methods, an encountered `Revision` is not in the index, a
 /// [`RevisionNotInIndex`] error is returned.
 ///
 /// In insert operations, the rule is thus that the `NodeMap` must always
 /// be updated after the `RevlogIndex`
 /// be updated first, and the `NodeMap` second.
 ///
 /// [`RevisionNotInIndex`]: enum.NodeMapError.html#variant.RevisionNotInIndex
 /// [`RevlogIndex`]: ../trait.RevlogIndex.html
 pub trait NodeMap {
     /// Find the unique `Revision` having the given `Node`
     ///
     /// If no Revision matches the given `Node`, `Ok(None)` is returned.
     fn find_node(
         &self,
         index: &impl RevlogIndex,
         node: &Node,
     ) -> Result<Option<Revision>, NodeMapError> {
         self.find_bin(index, node.into())
     }
 
     /// Find the unique Revision whose `Node` starts with a given binary prefix
     ///
     /// If no Revision matches the given prefix, `Ok(None)` is returned.
     ///
     /// If several Revisions match the given prefix, a [`MultipleResults`]
     /// error is returned.
-    fn find_bin<'a>(
+    fn find_bin(
         &self,
         idx: &impl RevlogIndex,
         prefix: NodePrefix,
     ) -> Result<Option<Revision>, NodeMapError>;
 
     /// Give the size of the shortest node prefix that determines
     /// the revision uniquely.
     ///
     /// From a binary node prefix, if it is matched in the node map, this
     /// returns the number of hexadecimal digits that would had sufficed
     /// to find the revision uniquely.
     ///
     /// Returns `None` if no `Revision` could be found for the prefix.
     ///
     /// If several Revisions match the given prefix, a [`MultipleResults`]
     /// error is returned.
-    fn unique_prefix_len_bin<'a>(
+    fn unique_prefix_len_bin(
         &self,
         idx: &impl RevlogIndex,
         node_prefix: NodePrefix,
     ) -> Result<Option<usize>, NodeMapError>;
 
     /// Same as `unique_prefix_len_bin`, with a full `Node` as input
     fn unique_prefix_len_node(
         &self,
         idx: &impl RevlogIndex,
         node: &Node,
     ) -> Result<Option<usize>, NodeMapError> {
         self.unique_prefix_len_bin(idx, node.into())
     }
 }
 
 pub trait MutableNodeMap: NodeMap {
     fn insert<I: RevlogIndex>(
         &mut self,
         index: &I,
         node: &Node,
         rev: Revision,
     ) -> Result<(), NodeMapError>;
 }
 
 /// Low level NodeTree [`Blocks`] elements
 ///
 /// These are exactly as for instance on persistent storage.
 type RawElement = unaligned::I32Be;
 
 /// High level representation of values in NodeTree
 /// [`Blocks`](struct.Block.html)
 ///
 /// This is the high level representation that most algorithms should
 /// use.
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum Element {
     Rev(Revision),
     Block(usize),
     None,
 }
 
 impl From<RawElement> for Element {
     /// Conversion from low level representation, after endianness conversion.
     ///
     /// See [`Block`](struct.Block.html) for explanation about the encoding.
     fn from(raw: RawElement) -> Element {
         let int = raw.get();
         if int >= 0 {
             Element::Block(int as usize)
         } else if int == -1 {
             Element::None
         } else {
             Element::Rev(-int - 2)
         }
     }
 }
 
 impl From<Element> for RawElement {
     fn from(element: Element) -> RawElement {
         RawElement::from(match element {
             Element::None => 0,
             Element::Block(i) => i as i32,
             Element::Rev(rev) => -rev - 2,
         })
     }
 }
 
 /// A logical block of the `NodeTree`, packed with a fixed size.
 ///
 /// These are always used in container types implementing `Index<Block>`,
 /// such as `&Block`
 ///
 /// As an array of integers, its ith element encodes that the
 /// ith potential edge from the block, representing the ith hexadecimal digit
 /// (nybble) `i` is either:
 ///
 /// - absent (value -1)
 /// - another `Block` in the same indexable container (value ≥ 0)
 ///  - a `Revision` leaf (value ≤ -2)
 ///
 /// Endianness has to be fixed for consistency on shared storage across
 /// different architectures.
 ///
 /// A key difference with the C `nodetree` is that we need to be
 /// able to represent the [`Block`] at index 0, hence -1 is the empty marker
 /// rather than 0 and the `Revision` range upper limit of -2 instead of -1.
 ///
 /// Another related difference is that `NULL_REVISION` (-1) is not
 /// represented at all, because we want an immutable empty nodetree
 /// to be valid.
 
 const ELEMENTS_PER_BLOCK: usize = 16; // number of different values in a nybble
 
 #[derive(Copy, Clone, BytesCast, PartialEq)]
 #[repr(transparent)]
 pub struct Block([RawElement; ELEMENTS_PER_BLOCK]);
 
 impl Block {
     fn new() -> Self {
         let absent_node = RawElement::from(-1);
         Block([absent_node; ELEMENTS_PER_BLOCK])
     }
 
     fn get(&self, nybble: u8) -> Element {
         self.0[nybble as usize].into()
     }
 
     fn set(&mut self, nybble: u8, element: Element) {
         self.0[nybble as usize] = element.into()
     }
 }
 
 impl fmt::Debug for Block {
     /// sparse representation for testing and debugging purposes
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_map()
             .entries((0..16).filter_map(|i| match self.get(i) {
                 Element::None => None,
                 element => Some((i, element)),
             }))
             .finish()
     }
 }
 
 /// A mutable 16-radix tree with the root block logically at the end
 ///
 /// Because of the append only nature of our node trees, we need to
 /// keep the original untouched and store new blocks separately.
 ///
 /// The mutable root `Block` is kept apart so that we don't have to rebump
 /// it on each insertion.
 pub struct NodeTree {
     readonly: Box<dyn Deref<Target = [Block]> + Send>,
     growable: Vec<Block>,
     root: Block,
     masked_inner_blocks: usize,
 }
 
 impl Index<usize> for NodeTree {
     type Output = Block;
 
     fn index(&self, i: usize) -> &Block {
         let ro_len = self.readonly.len();
         if i < ro_len {
             &self.readonly[i]
         } else if i == ro_len + self.growable.len() {
             &self.root
         } else {
             &self.growable[i - ro_len]
         }
     }
 }
 
 /// Return `None` unless the `Node` for `rev` has given prefix in `index`.
 fn has_prefix_or_none(
     idx: &impl RevlogIndex,
     prefix: NodePrefix,
     rev: Revision,
 ) -> Result<Option<Revision>, NodeMapError> {
     idx.node(rev)
-        .ok_or_else(|| NodeMapError::RevisionNotInIndex(rev))
+        .ok_or(NodeMapError::RevisionNotInIndex(rev))
         .map(|node| {
             if prefix.is_prefix_of(node) {
                 Some(rev)
             } else {
                 None
             }
         })
 }
 
 /// validate that the candidate's node starts indeed with given prefix,
 /// and treat ambiguities related to `NULL_REVISION`.
 ///
 /// From the data in the NodeTree, one can only conclude that some
 /// revision is the only one for a *subprefix* of the one being looked up.
 fn validate_candidate(
     idx: &impl RevlogIndex,
     prefix: NodePrefix,
     candidate: (Option<Revision>, usize),
 ) -> Result<(Option<Revision>, usize), NodeMapError> {
     let (rev, steps) = candidate;
     if let Some(nz_nybble) = prefix.first_different_nybble(&NULL_NODE) {
         rev.map_or(Ok((None, steps)), |r| {
             has_prefix_or_none(idx, prefix, r)
                 .map(|opt| (opt, max(steps, nz_nybble + 1)))
         })
     } else {
         // the prefix is only made of zeros; NULL_REVISION always matches it
         // and any other *valid* result is an ambiguity
         match rev {
             None => Ok((Some(NULL_REVISION), steps + 1)),
             Some(r) => match has_prefix_or_none(idx, prefix, r)? {
                 None => Ok((Some(NULL_REVISION), steps + 1)),
                 _ => Err(NodeMapError::MultipleResults),
             },
         }
     }
 }
 
 impl NodeTree {
     /// Initiate a NodeTree from an immutable slice-like of `Block`
     ///
     /// We keep `readonly` and clone its root block if it isn't empty.
     fn new(readonly: Box<dyn Deref<Target = [Block]> + Send>) -> Self {
         let root = readonly.last().cloned().unwrap_or_else(Block::new);
         NodeTree {
             readonly,
             growable: Vec::new(),
             root,
             masked_inner_blocks: 0,
         }
     }
 
     /// Create from an opaque bunch of bytes
     ///
     /// The created `NodeTreeBytes` from `buffer`,
     /// of which exactly `amount` bytes are used.
     ///
     /// - `buffer` could be derived from `PyBuffer` and `Mmap` objects.
     /// - `offset` allows for the final file format to include fixed data
     ///   (generation number, behavioural flags)
     /// - `amount` is expressed in bytes, and is not automatically derived from
     ///   `bytes`, so that a caller that manages them atomically can perform
     ///   temporary disk serializations and still rollback easily if needed.
     ///   First use-case for this would be to support Mercurial shell hooks.
     ///
     /// panics if `buffer` is smaller than `amount`
     pub fn load_bytes(
         bytes: Box<dyn Deref<Target = [u8]> + Send>,
         amount: usize,
     ) -> Self {
         NodeTree::new(Box::new(NodeTreeBytes::new(bytes, amount)))
     }
 
     /// Retrieve added `Block` and the original immutable data
     pub fn into_readonly_and_added(
         self,
     ) -> (Box<dyn Deref<Target = [Block]> + Send>, Vec<Block>) {
         let mut vec = self.growable;
         let readonly = self.readonly;
         if readonly.last() != Some(&self.root) {
             vec.push(self.root);
         }
         (readonly, vec)
     }
 
     /// Retrieve added `Blocks` as bytes, ready to be written to persistent
     /// storage
     pub fn into_readonly_and_added_bytes(
         self,
     ) -> (Box<dyn Deref<Target = [Block]> + Send>, Vec<u8>) {
         let (readonly, vec) = self.into_readonly_and_added();
         // Prevent running `v`'s destructor so we are in complete control
         // of the allocation.
         let vec = mem::ManuallyDrop::new(vec);
 
         // Transmute the `Vec<Block>` to a `Vec<u8>`. Blocks are contiguous
         // bytes, so this is perfectly safe.
         let bytes = unsafe {
             // Check for compatible allocation layout.
             // (Optimized away by constant-folding + dead code elimination.)
             assert_eq!(size_of::<Block>(), 64);
             assert_eq!(align_of::<Block>(), 1);
 
             // /!\ Any use of `vec` after this is use-after-free.
             // TODO: use `into_raw_parts` once stabilized
             Vec::from_raw_parts(
                 vec.as_ptr() as *mut u8,
                 vec.len() * size_of::<Block>(),
                 vec.capacity() * size_of::<Block>(),
             )
         };
         (readonly, bytes)
     }
 
     /// Total number of blocks
     fn len(&self) -> usize {
         self.readonly.len() + self.growable.len() + 1
     }
 
     /// Implemented for completeness
     ///
     /// A `NodeTree` always has at least the mutable root block.
     #[allow(dead_code)]
     fn is_empty(&self) -> bool {
         false
     }
 
     /// Main working method for `NodeTree` searches
     ///
     /// The first returned value is the result of analysing `NodeTree` data
     /// *alone*: whereas `None` guarantees that the given prefix is absent
     /// from the `NodeTree` data (but still could match `NULL_NODE`), with
     /// `Some(rev)`, it is to be understood that `rev` is the unique `Revision`
     /// that could match the prefix. Actually, all that can be inferred from
     /// the `NodeTree` data is that `rev` is the revision with the longest
     /// common node prefix with the given prefix.
     ///
     /// The second returned value is the size of the smallest subprefix
     /// of `prefix` that would give the same result, i.e. not the
     /// `MultipleResults` error variant (again, using only the data of the
     /// `NodeTree`).
     fn lookup(
         &self,
         prefix: NodePrefix,
     ) -> Result<(Option<Revision>, usize), NodeMapError> {
         for (i, visit_item) in self.visit(prefix).enumerate() {
             if let Some(opt) = visit_item.final_revision() {
                 return Ok((opt, i + 1));
             }
         }
         Err(NodeMapError::MultipleResults)
     }
 
     fn visit(&self, prefix: NodePrefix) -> NodeTreeVisitor {
         NodeTreeVisitor {
             nt: self,
             prefix,
             visit: self.len() - 1,
             nybble_idx: 0,
             done: false,
         }
     }
     /// Return a mutable reference for `Block` at index `idx`.
     ///
     /// If `idx` lies in the immutable area, then the reference is to
     /// a newly appended copy.
     ///
     /// Returns (new_idx, glen, mut_ref) where
     ///
     /// - `new_idx` is the index of the mutable `Block`
     /// - `mut_ref` is a mutable reference to the mutable Block.
     /// - `glen` is the new length of `self.growable`
     ///
     /// Note: the caller wouldn't be allowed to query `self.growable.len()`
     /// itself because of the mutable borrow taken with the returned `Block`
     fn mutable_block(&mut self, idx: usize) -> (usize, &mut Block, usize) {
         let ro_blocks = &self.readonly;
         let ro_len = ro_blocks.len();
         let glen = self.growable.len();
         if idx < ro_len {
             self.masked_inner_blocks += 1;
             self.growable.push(ro_blocks[idx]);
             (glen + ro_len, &mut self.growable[glen], glen + 1)
         } else if glen + ro_len == idx {
             (idx, &mut self.root, glen)
         } else {
             (idx, &mut self.growable[idx - ro_len], glen)
         }
     }
 
     /// Main insertion method
     ///
     /// This will dive in the node tree to find the deepest `Block` for
     /// `node`, split it as much as needed and record `node` in there.
     /// The method then backtracks, updating references in all the visited
     /// blocks from the root.
     ///
     /// All the mutated `Block` are copied first to the growable part if
     /// needed. That happens for those in the immutable part except the root.
     pub fn insert<I: RevlogIndex>(
         &mut self,
         index: &I,
         node: &Node,
         rev: Revision,
     ) -> Result<(), NodeMapError> {
         let ro_len = &self.readonly.len();
 
         let mut visit_steps: Vec<_> = self.visit(node.into()).collect();
         let read_nybbles = visit_steps.len();
         // visit_steps cannot be empty, since we always visit the root block
         let deepest = visit_steps.pop().unwrap();
 
         let (mut block_idx, mut block, mut glen) =
             self.mutable_block(deepest.block_idx);
 
         if let Element::Rev(old_rev) = deepest.element {
             let old_node = index
                 .node(old_rev)
-                .ok_or_else(|| NodeMapError::RevisionNotInIndex(old_rev))?;
+                .ok_or(NodeMapError::RevisionNotInIndex(old_rev))?;
             if old_node == node {
                 return Ok(()); // avoid creating lots of useless blocks
             }
 
             // Looping over the tail of nybbles in both nodes, creating
             // new blocks until we find the difference
             let mut new_block_idx = ro_len + glen;
             let mut nybble = deepest.nybble;
             for nybble_pos in read_nybbles..node.nybbles_len() {
                 block.set(nybble, Element::Block(new_block_idx));
 
                 let new_nybble = node.get_nybble(nybble_pos);
                 let old_nybble = old_node.get_nybble(nybble_pos);
 
                 if old_nybble == new_nybble {
                     self.growable.push(Block::new());
                     block = &mut self.growable[glen];
                     glen += 1;
                     new_block_idx += 1;
                     nybble = new_nybble;
                 } else {
                     let mut new_block = Block::new();
                     new_block.set(old_nybble, Element::Rev(old_rev));
                     new_block.set(new_nybble, Element::Rev(rev));
                     self.growable.push(new_block);
                     break;
                 }
             }
         } else {
             // Free slot in the deepest block: no splitting has to be done
             block.set(deepest.nybble, Element::Rev(rev));
         }
 
         // Backtrack over visit steps to update references
         while let Some(visited) = visit_steps.pop() {
             let to_write = Element::Block(block_idx);
             if visit_steps.is_empty() {
                 self.root.set(visited.nybble, to_write);
                 break;
             }
             let (new_idx, block, _) = self.mutable_block(visited.block_idx);
             if block.get(visited.nybble) == to_write {
                 break;
             }
             block.set(visited.nybble, to_write);
             block_idx = new_idx;
         }
         Ok(())
     }
 
     /// Make the whole `NodeTree` logically empty, without touching the
     /// immutable part.
     pub fn invalidate_all(&mut self) {
         self.root = Block::new();
         self.growable = Vec::new();
         self.masked_inner_blocks = self.readonly.len();
     }
 
     /// Return the number of blocks in the readonly part that are currently
     /// masked in the mutable part.
     ///
     /// The `NodeTree` structure has no efficient way to know how many blocks
     /// are already unreachable in the readonly part.
     ///
     /// After a call to `invalidate_all()`, the returned number can be actually
     /// bigger than the whole readonly part, a conventional way to mean that
     /// all the readonly blocks have been masked. This is what is really
     /// useful to the caller and does not require to know how many were
     /// actually unreachable to begin with.
     pub fn masked_readonly_blocks(&self) -> usize {
         if let Some(readonly_root) = self.readonly.last() {
             if readonly_root == &self.root {
                 return 0;
             }
         } else {
             return 0;
         }
         self.masked_inner_blocks + 1
     }
 }
 
 pub struct NodeTreeBytes {
     buffer: Box<dyn Deref<Target = [u8]> + Send>,
     len_in_blocks: usize,
 }
 
 impl NodeTreeBytes {
     fn new(
         buffer: Box<dyn Deref<Target = [u8]> + Send>,
         amount: usize,
     ) -> Self {
         assert!(buffer.len() >= amount);
         let len_in_blocks = amount / size_of::<Block>();
         NodeTreeBytes {
             buffer,
             len_in_blocks,
         }
     }
 }
 
 impl Deref for NodeTreeBytes {
     type Target = [Block];
 
     fn deref(&self) -> &[Block] {
         Block::slice_from_bytes(&self.buffer, self.len_in_blocks)
             // `NodeTreeBytes::new` already asserted that `self.buffer` is
             // large enough.
             .unwrap()
             .0
     }
 }
 
 struct NodeTreeVisitor<'n> {
     nt: &'n NodeTree,
     prefix: NodePrefix,
     visit: usize,
     nybble_idx: usize,
     done: bool,
 }
 
 #[derive(Debug, PartialEq, Clone)]
 struct NodeTreeVisitItem {
     block_idx: usize,
     nybble: u8,
     element: Element,
 }
 
 impl<'n> Iterator for NodeTreeVisitor<'n> {
     type Item = NodeTreeVisitItem;
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.done || self.nybble_idx >= self.prefix.nybbles_len() {
             return None;
         }
 
         let nybble = self.prefix.get_nybble(self.nybble_idx);
         self.nybble_idx += 1;
 
         let visit = self.visit;
         let element = self.nt[visit].get(nybble);
         if let Element::Block(idx) = element {
             self.visit = idx;
         } else {
             self.done = true;
         }
 
         Some(NodeTreeVisitItem {
             block_idx: visit,
             nybble,
             element,
         })
     }
 }
 
 impl NodeTreeVisitItem {
     // Return `Some(opt)` if this item is final, with `opt` being the
     // `Revision` that it may represent.
     //
     // If the item is not terminal, return `None`
     fn final_revision(&self) -> Option<Option<Revision>> {
         match self.element {
             Element::Block(_) => None,
             Element::Rev(r) => Some(Some(r)),
             Element::None => Some(None),
         }
     }
 }
 
 impl From<Vec<Block>> for NodeTree {
     fn from(vec: Vec<Block>) -> Self {
         Self::new(Box::new(vec))
     }
 }
 
 impl fmt::Debug for NodeTree {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let readonly: &[Block] = &*self.readonly;
         write!(
             f,
             "readonly: {:?}, growable: {:?}, root: {:?}",
             readonly, self.growable, self.root
         )
     }
 }
 
 impl Default for NodeTree {
     /// Create a fully mutable empty NodeTree
     fn default() -> Self {
         NodeTree::new(Box::new(Vec::new()))
     }
 }
 
 impl NodeMap for NodeTree {
     fn find_bin<'a>(
         &self,
         idx: &impl RevlogIndex,
         prefix: NodePrefix,
     ) -> Result<Option<Revision>, NodeMapError> {
         validate_candidate(idx, prefix, self.lookup(prefix)?)
             .map(|(opt, _shortest)| opt)
     }
 
     fn unique_prefix_len_bin<'a>(
         &self,
         idx: &impl RevlogIndex,
         prefix: NodePrefix,
     ) -> Result<Option<usize>, NodeMapError> {
         validate_candidate(idx, prefix, self.lookup(prefix)?)
             .map(|(opt, shortest)| opt.map(|_rev| shortest))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::NodeMapError::*;
     use super::*;
     use crate::revlog::node::{hex_pad_right, Node};
     use std::collections::HashMap;
 
     /// Creates a `Block` using a syntax close to the `Debug` output
     macro_rules! block {
         {$($nybble:tt : $variant:ident($val:tt)),*} => (
             {
                 let mut block = Block::new();
                 $(block.set($nybble, Element::$variant($val)));*;
                 block
             }
         )
     }
 
     #[test]
     fn test_block_debug() {
         let mut block = Block::new();
         block.set(1, Element::Rev(3));
         block.set(10, Element::Block(0));
         assert_eq!(format!("{:?}", block), "{1: Rev(3), 10: Block(0)}");
     }
 
     #[test]
     fn test_block_macro() {
         let block = block! {5: Block(2)};
         assert_eq!(format!("{:?}", block), "{5: Block(2)}");
 
         let block = block! {13: Rev(15), 5: Block(2)};
         assert_eq!(format!("{:?}", block), "{5: Block(2), 13: Rev(15)}");
     }
 
     #[test]
     fn test_raw_block() {
         let mut raw = [255u8; 64];
 
         let mut counter = 0;
         for val in [0_i32, 15, -2, -1, -3].iter() {
             for byte in val.to_be_bytes().iter() {
                 raw[counter] = *byte;
                 counter += 1;
             }
         }
         let (block, _) = Block::from_bytes(&raw).unwrap();
         assert_eq!(block.get(0), Element::Block(0));
         assert_eq!(block.get(1), Element::Block(15));
         assert_eq!(block.get(3), Element::None);
         assert_eq!(block.get(2), Element::Rev(0));
         assert_eq!(block.get(4), Element::Rev(1));
     }
 
     type TestIndex = HashMap<Revision, Node>;
 
     impl RevlogIndex for TestIndex {
         fn node(&self, rev: Revision) -> Option<&Node> {
             self.get(&rev)
         }
 
         fn len(&self) -> usize {
             self.len()
         }
     }
 
     /// Pad hexadecimal Node prefix with zeros on the right
     ///
     /// This avoids having to repeatedly write very long hexadecimal
     /// strings for test data, and brings actual hash size independency.
     #[cfg(test)]
     fn pad_node(hex: &str) -> Node {
         Node::from_hex(&hex_pad_right(hex)).unwrap()
     }
 
     /// Pad hexadecimal Node prefix with zeros on the right, then insert
     fn pad_insert(idx: &mut TestIndex, rev: Revision, hex: &str) {
         idx.insert(rev, pad_node(hex));
     }
 
     fn sample_nodetree() -> NodeTree {
         NodeTree::from(vec![
             block![0: Rev(9)],
             block![0: Rev(0), 1: Rev(9)],
             block![0: Block(1), 1:Rev(1)],
         ])
     }
 
     fn hex(s: &str) -> NodePrefix {
         NodePrefix::from_hex(s).unwrap()
     }
 
     #[test]
     fn test_nt_debug() {
         let nt = sample_nodetree();
         assert_eq!(
             format!("{:?}", nt),
             "readonly: \
              [{0: Rev(9)}, {0: Rev(0), 1: Rev(9)}, {0: Block(1), 1: Rev(1)}], \
              growable: [], \
              root: {0: Block(1), 1: Rev(1)}",
         );
     }
 
     #[test]
     fn test_immutable_find_simplest() -> Result<(), NodeMapError> {
         let mut idx: TestIndex = HashMap::new();
         pad_insert(&mut idx, 1, "1234deadcafe");
 
         let nt = NodeTree::from(vec![block! {1: Rev(1)}]);
         assert_eq!(nt.find_bin(&idx, hex("1"))?, Some(1));
         assert_eq!(nt.find_bin(&idx, hex("12"))?, Some(1));
         assert_eq!(nt.find_bin(&idx, hex("1234de"))?, Some(1));
         assert_eq!(nt.find_bin(&idx, hex("1a"))?, None);
         assert_eq!(nt.find_bin(&idx, hex("ab"))?, None);
 
         // and with full binary Nodes
         assert_eq!(nt.find_node(&idx, idx.get(&1).unwrap())?, Some(1));
         let unknown = Node::from_hex(&hex_pad_right("3d")).unwrap();
         assert_eq!(nt.find_node(&idx, &unknown)?, None);
         Ok(())
     }
 
     #[test]
     fn test_immutable_find_one_jump() {
         let mut idx = TestIndex::new();
         pad_insert(&mut idx, 9, "012");
         pad_insert(&mut idx, 0, "00a");
 
         let nt = sample_nodetree();
 
         assert_eq!(nt.find_bin(&idx, hex("0")), Err(MultipleResults));
         assert_eq!(nt.find_bin(&idx, hex("01")), Ok(Some(9)));
         assert_eq!(nt.find_bin(&idx, hex("00")), Err(MultipleResults));
         assert_eq!(nt.find_bin(&idx, hex("00a")), Ok(Some(0)));
         assert_eq!(nt.unique_prefix_len_bin(&idx, hex("00a")), Ok(Some(3)));
         assert_eq!(nt.find_bin(&idx, hex("000")), Ok(Some(NULL_REVISION)));
     }
 
     #[test]
     fn test_mutated_find() -> Result<(), NodeMapError> {
         let mut idx = TestIndex::new();
         pad_insert(&mut idx, 9, "012");
         pad_insert(&mut idx, 0, "00a");
         pad_insert(&mut idx, 2, "cafe");
         pad_insert(&mut idx, 3, "15");
         pad_insert(&mut idx, 1, "10");
 
         let nt = NodeTree {
             readonly: sample_nodetree().readonly,
             growable: vec![block![0: Rev(1), 5: Rev(3)]],
             root: block![0: Block(1), 1:Block(3), 12: Rev(2)],
             masked_inner_blocks: 1,
         };
         assert_eq!(nt.find_bin(&idx, hex("10"))?, Some(1));
         assert_eq!(nt.find_bin(&idx, hex("c"))?, Some(2));
         assert_eq!(nt.unique_prefix_len_bin(&idx, hex("c"))?, Some(1));
         assert_eq!(nt.find_bin(&idx, hex("00")), Err(MultipleResults));
         assert_eq!(nt.find_bin(&idx, hex("000"))?, Some(NULL_REVISION));
         assert_eq!(nt.unique_prefix_len_bin(&idx, hex("000"))?, Some(3));
         assert_eq!(nt.find_bin(&idx, hex("01"))?, Some(9));
         assert_eq!(nt.masked_readonly_blocks(), 2);
         Ok(())
     }
 
     struct TestNtIndex {
         index: TestIndex,
         nt: NodeTree,
     }
 
     impl TestNtIndex {
         fn new() -> Self {
             TestNtIndex {
                 index: HashMap::new(),
                 nt: NodeTree::default(),
             }
         }
 
         fn insert(
             &mut self,
             rev: Revision,
             hex: &str,
         ) -> Result<(), NodeMapError> {
             let node = pad_node(hex);
-            self.index.insert(rev, node.clone());
+            self.index.insert(rev, node);
             self.nt.insert(&self.index, &node, rev)?;
             Ok(())
         }
 
         fn find_hex(
             &self,
             prefix: &str,
         ) -> Result<Option<Revision>, NodeMapError> {
             self.nt.find_bin(&self.index, hex(prefix))
         }
 
         fn unique_prefix_len_hex(
             &self,
             prefix: &str,
         ) -> Result<Option<usize>, NodeMapError> {
             self.nt.unique_prefix_len_bin(&self.index, hex(prefix))
         }
 
         /// Drain `added` and restart a new one
         fn commit(self) -> Self {
             let mut as_vec: Vec<Block> =
-                self.nt.readonly.iter().map(|block| block.clone()).collect();
+                self.nt.readonly.iter().copied().collect();
             as_vec.extend(self.nt.growable);
             as_vec.push(self.nt.root);
 
             Self {
                 index: self.index,
-                nt: NodeTree::from(as_vec).into(),
+                nt: NodeTree::from(as_vec),
             }
         }
     }
 
     #[test]
     fn test_insert_full_mutable() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
         idx.insert(0, "1234")?;
         assert_eq!(idx.find_hex("1")?, Some(0));
         assert_eq!(idx.find_hex("12")?, Some(0));
 
         // let's trigger a simple split
         idx.insert(1, "1a34")?;
         assert_eq!(idx.nt.growable.len(), 1);
         assert_eq!(idx.find_hex("12")?, Some(0));
         assert_eq!(idx.find_hex("1a")?, Some(1));
 
         // reinserting is a no_op
         idx.insert(1, "1a34")?;
         assert_eq!(idx.nt.growable.len(), 1);
         assert_eq!(idx.find_hex("12")?, Some(0));
         assert_eq!(idx.find_hex("1a")?, Some(1));
 
         idx.insert(2, "1a01")?;
         assert_eq!(idx.nt.growable.len(), 2);
         assert_eq!(idx.find_hex("1a"), Err(NodeMapError::MultipleResults));
         assert_eq!(idx.find_hex("12")?, Some(0));
         assert_eq!(idx.find_hex("1a3")?, Some(1));
         assert_eq!(idx.find_hex("1a0")?, Some(2));
         assert_eq!(idx.find_hex("1a12")?, None);
 
         // now let's make it split and create more than one additional block
         idx.insert(3, "1a345")?;
         assert_eq!(idx.nt.growable.len(), 4);
         assert_eq!(idx.find_hex("1a340")?, Some(1));
         assert_eq!(idx.find_hex("1a345")?, Some(3));
         assert_eq!(idx.find_hex("1a341")?, None);
 
         // there's no readonly block to mask
         assert_eq!(idx.nt.masked_readonly_blocks(), 0);
         Ok(())
     }
 
     #[test]
     fn test_unique_prefix_len_zero_prefix() {
         let mut idx = TestNtIndex::new();
         idx.insert(0, "00000abcd").unwrap();
 
         assert_eq!(idx.find_hex("000"), Err(NodeMapError::MultipleResults));
         // in the nodetree proper, this will be found at the first nybble
         // yet the correct answer for unique_prefix_len is not 1, nor 1+1,
         // but the first difference with `NULL_NODE`
         assert_eq!(idx.unique_prefix_len_hex("00000a"), Ok(Some(6)));
         assert_eq!(idx.unique_prefix_len_hex("00000ab"), Ok(Some(6)));
 
         // same with odd result
         idx.insert(1, "00123").unwrap();
         assert_eq!(idx.unique_prefix_len_hex("001"), Ok(Some(3)));
         assert_eq!(idx.unique_prefix_len_hex("0012"), Ok(Some(3)));
 
         // these are unchanged of course
         assert_eq!(idx.unique_prefix_len_hex("00000a"), Ok(Some(6)));
         assert_eq!(idx.unique_prefix_len_hex("00000ab"), Ok(Some(6)));
     }
 
     #[test]
     fn test_insert_extreme_splitting() -> Result<(), NodeMapError> {
         // check that the splitting loop is long enough
         let mut nt_idx = TestNtIndex::new();
         let nt = &mut nt_idx.nt;
         let idx = &mut nt_idx.index;
 
         let node0_hex = hex_pad_right("444444");
-        let mut node1_hex = hex_pad_right("444444").clone();
+        let mut node1_hex = hex_pad_right("444444");
         node1_hex.pop();
         node1_hex.push('5');
         let node0 = Node::from_hex(&node0_hex).unwrap();
         let node1 = Node::from_hex(&node1_hex).unwrap();
 
-        idx.insert(0, node0.clone());
+        idx.insert(0, node0);
         nt.insert(idx, &node0, 0)?;
-        idx.insert(1, node1.clone());
+        idx.insert(1, node1);
         nt.insert(idx, &node1, 1)?;
 
         assert_eq!(nt.find_bin(idx, (&node0).into())?, Some(0));
         assert_eq!(nt.find_bin(idx, (&node1).into())?, Some(1));
         Ok(())
     }
 
     #[test]
     fn test_insert_partly_immutable() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
         idx.insert(0, "1234")?;
         idx.insert(1, "1235")?;
         idx.insert(2, "131")?;
         idx.insert(3, "cafe")?;
         let mut idx = idx.commit();
         assert_eq!(idx.find_hex("1234")?, Some(0));
         assert_eq!(idx.find_hex("1235")?, Some(1));
         assert_eq!(idx.find_hex("131")?, Some(2));
         assert_eq!(idx.find_hex("cafe")?, Some(3));
         // we did not add anything since init from readonly
         assert_eq!(idx.nt.masked_readonly_blocks(), 0);
 
         idx.insert(4, "123A")?;
         assert_eq!(idx.find_hex("1234")?, Some(0));
         assert_eq!(idx.find_hex("1235")?, Some(1));
         assert_eq!(idx.find_hex("131")?, Some(2));
         assert_eq!(idx.find_hex("cafe")?, Some(3));
         assert_eq!(idx.find_hex("123A")?, Some(4));
         // we masked blocks for all prefixes of "123", including the root
         assert_eq!(idx.nt.masked_readonly_blocks(), 4);
 
         eprintln!("{:?}", idx.nt);
         idx.insert(5, "c0")?;
         assert_eq!(idx.find_hex("cafe")?, Some(3));
         assert_eq!(idx.find_hex("c0")?, Some(5));
         assert_eq!(idx.find_hex("c1")?, None);
         assert_eq!(idx.find_hex("1234")?, Some(0));
         // inserting "c0" is just splitting the 'c' slot of the mutable root,
         // it doesn't mask anything
         assert_eq!(idx.nt.masked_readonly_blocks(), 4);
 
         Ok(())
     }
 
     #[test]
     fn test_invalidate_all() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
         idx.insert(0, "1234")?;
         idx.insert(1, "1235")?;
         idx.insert(2, "131")?;
         idx.insert(3, "cafe")?;
         let mut idx = idx.commit();
 
         idx.nt.invalidate_all();
 
         assert_eq!(idx.find_hex("1234")?, None);
         assert_eq!(idx.find_hex("1235")?, None);
         assert_eq!(idx.find_hex("131")?, None);
         assert_eq!(idx.find_hex("cafe")?, None);
         // all the readonly blocks have been masked, this is the
         // conventional expected response
         assert_eq!(idx.nt.masked_readonly_blocks(), idx.nt.readonly.len() + 1);
         Ok(())
     }
 
     #[test]
     fn test_into_added_empty() {
         assert!(sample_nodetree().into_readonly_and_added().1.is_empty());
         assert!(sample_nodetree()
             .into_readonly_and_added_bytes()
             .1
             .is_empty());
     }
 
     #[test]
     fn test_into_added_bytes() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
         idx.insert(0, "1234")?;
         let mut idx = idx.commit();
         idx.insert(4, "cafe")?;
         let (_, bytes) = idx.nt.into_readonly_and_added_bytes();
 
         // only the root block has been changed
         assert_eq!(bytes.len(), size_of::<Block>());
         // big endian for -2
         assert_eq!(&bytes[4..2 * 4], [255, 255, 255, 254]);
         // big endian for -6
         assert_eq!(&bytes[12 * 4..13 * 4], [255, 255, 255, 250]);
         Ok(())
     }
 }