rust: run a clippy pass with the latest stable version

Our current version of clippy is older than the latest stable.
The newest version has new lints that are moslty good advice, so let's apply
them ahead of time. This has the added benefit of reducing the noise for
developpers like myself that use clippy as an IDE helper, as well as being
more prepared for a future clippy upgrade.

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

@@ -107,7 +107,7 b' impl ConfigLayer {'
     ) {
         self.sections
             .entry(section)
-            .or_insert_with(HashMap::new)
+            .or_default()
             .insert(item, ConfigValue { bytes: value, line });
     }
 
@@ -178,7 +178,7 b' impl ConfigLayer {'
                     .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));
+                let filename = dir.join(get_path_from_bytes(&filename_bytes));
                 match std::fs::read(&filename) {
                     Ok(data) => {
                         layers.push(current_layer);

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

@@ -758,7 +758,7 b' mod tests {'
         let tmpdir = tempfile::tempdir().unwrap();
         let tmpdir_path = tmpdir.path();
         let mut included_file =
-            File::create(&tmpdir_path.join("included.rc")).unwrap();
+            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");

rust/hg-core/src/dagops.rs

@@ -205,8 +205,7 b' mod tests {'
         graph: &impl Graph,
         revs: &[BaseRevision],
     ) -> Result<Vec<Revision>, GraphError> {
-        let iter_revs: Vec<_> =
-            revs.into_iter().cloned().map(Revision).collect();
+        let iter_revs: Vec<_> = revs.iter().cloned().map(Revision).collect();
         let heads = heads(graph, iter_revs.iter())?;
         let mut as_vec: Vec<Revision> = heads.iter().cloned().collect();
         as_vec.sort_unstable();

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

@@ -178,7 +178,7 b" impl<'on_disk> ChildNodes<'on_disk> {"
             ChildNodes::InMemory(nodes) => Ok(nodes),
             ChildNodes::OnDisk(nodes) => {
                 *unreachable_bytes +=
-                    std::mem::size_of_val::<[on_disk::Node]>(nodes) as u32;
+                    std::mem::size_of_val::<[on_disk::Node]>(*nodes) as u32;
                 let nodes = nodes
                     .iter()
                     .map(|node| {
@@ -764,7 +764,7 b" impl<'on_disk> DirstateMap<'on_disk> {"
     ) -> 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 tracked_count_increment = u32::from(!was_tracked);
         let mut new = false;
 
         let node = self.get_or_insert_node(filename, |ancestor| {

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

@@ -249,7 +249,7 b" impl<'a> HasIgnoredAncestor<'a> {"
         }
     }
 
-    fn force<'b>(&self, ignore_fn: &IgnoreFnType<'b>) -> bool {
+    fn force(&self, ignore_fn: &IgnoreFnType<'_>) -> bool {
         match self.parent {
             None => false,
             Some(parent) => {

rust/hg-core/src/discovery.rs

@@ -332,7 +332,7 b' impl<G: Graph + Clone> PartialDiscovery<'
             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);
+                children.entry(p).or_default().push(rev);
             }
         }
         self.children_cache = Some(children);
@@ -695,7 +695,7 b' mod tests {'
     #[test]
     fn test_bidirectional_sample() -> Result<(), GraphError> {
         let mut disco = full_disco();
-        disco.undecided = Some((0..=13).into_iter().map(Revision).collect());
+        disco.undecided = Some((0..=13).map(Revision).collect());
 
         let (sample_set, size) = disco.bidirectional_sample(7)?;
         assert_eq!(size, 7);

rust/hg-core/src/filepatterns.rs

@@ -629,8 +629,7 b' impl SubInclude {'
             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 source_root = source_root.parent().unwrap_or(source_root);
 
         let path = source_root.join(get_path_from_bytes(pattern));
         let new_root = path.parent().unwrap_or_else(|| path.deref());
@@ -682,22 +681,21 b' mod tests {'
         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()
+            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#"\.\*\?"#);
+        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]

rust/hg-core/src/matchers.rs

@@ -28,7 +28,6 b' use crate::dirstate::status::IgnoreFnTyp'
 use crate::filepatterns::normalize_path_bytes;
 use std::collections::HashSet;
 use std::fmt::{Display, Error, Formatter};
-use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::{borrow::ToOwned, collections::BTreeSet};
 
@@ -183,7 +182,7 b' impl FileMatcher {'
     pub fn new(files: Vec<HgPathBuf>) -> Result<Self, HgPathError> {
         let dirs = DirsMultiset::from_manifest(&files)?;
         Ok(Self {
-            files: HashSet::from_iter(files.into_iter()),
+            files: HashSet::from_iter(files),
             dirs,
             sorted_visitchildrenset_candidates: OnceCell::new(),
         })
@@ -316,7 +315,7 b" impl<'a> PatternMatcher<'a> {"
     pub fn new(ignore_patterns: Vec<IgnorePattern>) -> PatternResult<Self> {
         let (files, _) = roots_and_dirs(&ignore_patterns);
         let dirs = DirsMultiset::from_manifest(&files)?;
-        let files: HashSet<HgPathBuf> = HashSet::from_iter(files.into_iter());
+        let files: HashSet<HgPathBuf> = HashSet::from_iter(files);
 
         let prefix = ignore_patterns.iter().all(|k| {
             matches!(k.syntax, PatternSyntax::Path | PatternSyntax::RelPath)
@@ -773,10 +772,10 b' fn re_matcher(pattern: &[u8]) -> Pattern'
 
 /// 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],
+fn build_regex_match<'a>(
+    ignore_patterns: &[IgnorePattern],
     glob_suffix: &[u8],
-) -> PatternResult<(Vec<u8>, IgnoreFnType<'b>)> {
+) -> PatternResult<(Vec<u8>, IgnoreFnType<'a>)> {
     let mut regexps = vec![];
     let mut exact_set = HashSet::new();
 
@@ -958,7 +957,7 b" fn build_match<'a>("
                 } else {
                     b"."
                 };
-                dirs.contains(dir.deref())
+                dirs.contains(dir)
             };
             match_funcs.push(Box::new(match_func));
 

rust/hg-core/src/repo.rs

@@ -686,7 +686,7 b' impl Repo {'
                 }
                 file.write_all(&data)?;
                 file.flush()?;
-                file.seek(SeekFrom::Current(0))
+                file.stream_position()
             })()
             .when_writing_file(&data_filename)?;
 

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

@@ -248,8 +248,8 b' impl Revlog {'
     ) -> Result<Self, HgError> {
         let index_path = index_path.as_ref();
         let index = {
-            match store_vfs.mmap_open_opt(&index_path)? {
-                None => Index::new(Box::new(vec![])),
+            match store_vfs.mmap_open_opt(index_path)? {
+                None => Index::new(Box::<Vec<_>>::default()),
                 Some(index_mmap) => {
                     let index = Index::new(Box::new(index_mmap))?;
                     Ok(index)

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

@@ -348,7 +348,7 b' mod tests {'
         assert_eq!(Node::from_hex(SAMPLE_NODE_HEX).unwrap(), SAMPLE_NODE);
         assert!(Node::from_hex(not_hex).is_err());
         assert!(Node::from_hex(too_short).is_err());
-        assert!(Node::from_hex(&too_long).is_err());
+        assert!(Node::from_hex(too_long).is_err());
     }
 
     #[test]

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

@@ -656,7 +656,7 b' impl From<Vec<Block>> for NodeTree {'
 
 impl fmt::Debug for NodeTree {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let readonly: &[Block] = &*self.readonly;
+        let readonly: &[Block] = &self.readonly;
         write!(
             f,
             "readonly: {:?}, growable: {:?}, root: {:?}",
@@ -668,7 +668,7 b' impl fmt::Debug for NodeTree {'
 impl Default for NodeTree {
     /// Create a fully mutable empty NodeTree
     fn default() -> Self {
-        NodeTree::new(Box::new(Vec::new()))
+        NodeTree::new(Box::<Vec<_>>::default())
     }
 }
 
@@ -775,7 +775,7 b' pub mod tests {'
     /// 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()
+        Node::from_hex(hex_pad_right(hex)).unwrap()
     }
 
     /// Pad hexadecimal Node prefix with zeros on the right, then insert
@@ -824,7 +824,7 b' pub mod tests {'
             nt.find_node(&idx, idx.get(&1.into()).unwrap())?,
             Some(R!(1))
         );
-        let unknown = Node::from_hex(&hex_pad_right("3d")).unwrap();
+        let unknown = Node::from_hex(hex_pad_right("3d")).unwrap();
         assert_eq!(nt.find_node(&idx, &unknown)?, None);
         Ok(())
     }
@@ -900,7 +900,7 b' pub mod tests {'
             hex: &str,
         ) -> Result<(), NodeMapError> {
             let node = pad_node(hex);
-            return self.insert_node(rev, node);
+            self.insert_node(rev, node)
         }
 
         fn find_hex(
@@ -931,6 +931,12 b' pub mod tests {'
         }
     }
 
+    impl Default for TestNtIndex {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
     #[test]
     fn test_insert_full_mutable() -> Result<(), NodeMapError> {
         let mut idx = TestNtIndex::new();
@@ -1003,7 +1009,7 b' pub mod tests {'
         let mut node1_hex = hex_pad_right("444444");
         node1_hex.pop();
         node1_hex.push('5');
-        let node0 = Node::from_hex(&node0_hex).unwrap();
+        let node0 = Node::from_hex(node0_hex).unwrap();
         let node1 = Node::from_hex(&node1_hex).unwrap();
 
         idx.insert(0.into(), node0);

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

@@ -75,7 +75,7 b' impl NodeMapDocket {'
         // TODO: use `vfs.read()` here when the `persistent-nodemap.mmap`
         // config is false?
         if let Some(mmap) =
-            store_vfs.mmap_open(&data_path).io_not_found_as_none()?
+            store_vfs.mmap_open(data_path).io_not_found_as_none()?
         {
             if mmap.len() >= data_length {
                 Ok(Some((docket, mmap)))

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

@@ -192,13 +192,13 b' pub fn canonical_path('
     let name = name.as_ref();
 
     let name = if !name.is_absolute() {
-        root.join(&cwd).join(&name)
+        root.join(cwd).join(name)
     } else {
         name.to_owned()
     };
-    let auditor = PathAuditor::new(&root);
-    if name != root && name.starts_with(&root) {
-        let name = name.strip_prefix(&root).unwrap();
+    let auditor = PathAuditor::new(root);
+    if name != root && name.starts_with(root) {
+        let name = name.strip_prefix(root).unwrap();
         auditor.audit_path(path_to_hg_path_buf(name)?)?;
         Ok(name.to_owned())
     } else if name == root {
@@ -210,7 +210,7 b' pub fn canonical_path('
         let mut name = name.deref();
         let original_name = name.to_owned();
         loop {
-            let same = is_same_file(&name, &root).unwrap_or(false);
+            let same = is_same_file(name, root).unwrap_or(false);
             if same {
                 if name == original_name {
                     // `name` was actually the same as root (maybe a symlink)
@@ -218,8 +218,8 b' pub fn canonical_path('
                 }
                 // `name` is a symlink to root, so `original_name` is under
                 // root
-                let rel_path = original_name.strip_prefix(&name).unwrap();
-                auditor.audit_path(path_to_hg_path_buf(&rel_path)?)?;
+                let rel_path = original_name.strip_prefix(name).unwrap();
+                auditor.audit_path(path_to_hg_path_buf(rel_path)?)?;
                 return Ok(rel_path.to_owned());
             }
             name = match name.parent() {
@@ -429,7 +429,7 b' mod tests {'
             })
         );
         assert_eq!(
-            canonical_path(&root, Path::new(""), &under_repo_symlink),
+            canonical_path(&root, Path::new(""), under_repo_symlink),
             Ok(PathBuf::from("d"))
         );
     }

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

@@ -117,7 +117,7 b' impl PathAuditor {'
             if self.audited_dirs.read().unwrap().contains(prefix) {
                 continue;
             }
-            self.check_filesystem(&prefix, &path)?;
+            self.check_filesystem(prefix, path)?;
             self.audited_dirs.write().unwrap().insert(prefix.to_owned());
         }
 
@@ -203,12 +203,12 b' mod tests {'
             })
         );
 
-        create_dir(&base_dir_path.join("realdir")).unwrap();
-        File::create(&base_dir_path.join("realdir/realfile")).unwrap();
+        create_dir(base_dir_path.join("realdir")).unwrap();
+        File::create(base_dir_path.join("realdir/realfile")).unwrap();
         // TODO make portable
         std::os::unix::fs::symlink(
-            &base_dir_path.join("realdir"),
-            &base_dir_path.join("symlink"),
+            base_dir_path.join("realdir"),
+            base_dir_path.join("symlink"),
         )
         .unwrap();
         let path = HgPath::new(b"symlink/realfile");

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

@@ -273,7 +273,7 b' fn build_response('
                 py_warnings.append(
                     py,
                     (
-                        PyBytes::new(py, &get_bytes_from_path(&file)),
+                        PyBytes::new(py, &get_bytes_from_path(file)),
                         PyBytes::new(py, syn),
                     )
                         .to_py_object(py)
@@ -282,7 +282,7 b' fn build_response('
             }
             PatternFileWarning::NoSuchFile(file) => py_warnings.append(
                 py,
-                PyBytes::new(py, &get_bytes_from_path(&file)).into_object(),
+                PyBytes::new(py, &get_bytes_from_path(file)).into_object(),
             ),
         }
     }

rust/hg-cpython/src/revlog.rs

@@ -348,7 +348,7 b' impl MixedIndex {'
         py: Python<'a>,
     ) -> PyResult<&'a RefCell<Option<NodeTree>>> {
         if self.nt(py).borrow().is_none() {
-            let readonly = Box::new(Vec::new());
+            let readonly = Box::<Vec<_>>::default();
             let mut nt = NodeTree::load_bytes(readonly, 0);
             self.fill_nodemap(py, &mut nt)?;
             self.nt(py).borrow_mut().replace(nt);
@@ -382,7 +382,7 b' impl MixedIndex {'
         // If there's anything readonly, we need to build the data again from
         // scratch
         let bytes = if readonly.len() > 0 {
-            let mut nt = NodeTree::load_bytes(Box::new(vec![]), 0);
+            let mut nt = NodeTree::load_bytes(Box::<Vec<_>>::default(), 0);
             self.fill_nodemap(py, &mut nt)?;
 
             let (readonly, bytes) = nt.into_readonly_and_added_bytes();

rust/rhg/src/commands/cat.rs

@@ -62,7 +62,7 b' pub fn run(invocation: &crate::CliInvoca'
             return Err(CommandError::unsupported(message));
         }
 
-        let normalized = cwd.join(&file);
+        let normalized = cwd.join(file);
         // TODO: actually normalize `..` path segments etc?
         let dotted = normalized.components().any(|c| c.as_os_str() == "..");
         if file.as_bytes() == b"." || dotted {

rust/rhg/src/commands/debugdata.rs

@@ -23,7 +23,7 b' pub fn args() -> clap::Command {'
         )
         .group(
             ArgGroup::new("revlog")
-                .args(&["changelog", "manifest"])
+                .args(["changelog", "manifest"])
                 .required(true),
         )
         .arg(

rust/rhg/src/commands/root.rs

@@ -20,7 +20,7 b' pub fn run(invocation: &crate::CliInvoca'
         .with_context(|| {
             IoErrorContext::CanonicalizingPath(working_directory.to_owned())
         })?;
-    let bytes = get_bytes_from_path(&working_directory);
+    let bytes = get_bytes_from_path(working_directory);
     invocation
         .ui
         .write_stdout(&format_bytes!(b"{}\n", bytes.as_slice()))?;

rust/rhg/src/main.rs

@@ -404,8 +404,8 b' fn exit_code('
     }
 }
 
-fn exit<'a>(
-    original_args: &'a [OsString],
+fn exit(
+    original_args: &[OsString],
     initial_current_dir: &Option<PathBuf>,
     ui: &Ui,
     mut on_unsupported: OnUnsupported,

rust/rhg/src/ui.rs

@@ -251,7 +251,7 b' pub(crate) fn format_pattern_file_warnin'
         PatternFileWarning::InvalidSyntax(path, syntax) => format_bytes!(
             b"{}: ignoring invalid syntax '{}'\n",
             get_bytes_from_path(path),
-            &*syntax
+            syntax
         ),
         PatternFileWarning::NoSuchFile(path) => {
             let path = if let Ok(relative) =
@@ -259,7 +259,7 b' pub(crate) fn format_pattern_file_warnin'
             {
                 relative
             } else {
-                &*path
+                path
             };
             format_bytes!(
                 b"skipping unreadable pattern file '{}': \