fix!: use dyn trait where possible.

This reduces compile time due to avoiding duplication.

Author: Byron

gix-features/src/cache.rs

@@ -11,9 +11,9 @@ mod impl_ {
     impl Debug {
         /// Create a new instance
         #[inline]
-        pub fn new(owner: impl Into<String>) -> Self {
+        pub fn new(owner: String) -> Self {
             Debug {
-                owner: owner.into(),
+                owner,
                 hits: 0,
                 puts: 0,
                 misses: 0,
@@ -61,7 +61,7 @@ mod impl_ {
     impl Debug {
         /// Create a new instance
         #[inline]
-        pub fn new(_owner: impl Into<String>) -> Self {
+        pub fn new(_owner: String) -> Self {
             Debug
         }
         /// noop

gix-features/src/fs.rs

@@ -58,12 +58,12 @@ pub mod walkdir {
     }
 
     /// Instantiate a new directory iterator which will not skip hidden files, with the given level of `parallelism`.
-    pub fn walkdir_new(root: impl AsRef<Path>, parallelism: Parallelism) -> WalkDir {
+    pub fn walkdir_new(root: &Path, parallelism: Parallelism) -> WalkDir {
         WalkDir::new(root).skip_hidden(false).parallelism(parallelism.into())
     }
 
     /// Instantiate a new directory iterator which will not skip hidden files and is sorted
-    pub fn walkdir_sorted_new(root: impl AsRef<Path>, parallelism: Parallelism) -> WalkDir {
+    pub fn walkdir_sorted_new(root: &Path, parallelism: Parallelism) -> WalkDir {
         WalkDir::new(root)
             .skip_hidden(false)
             .sort(true)
@@ -84,12 +84,12 @@ pub mod walkdir {
     pub use super::shared::Parallelism;
 
     /// Instantiate a new directory iterator which will not skip hidden files, with the given level of `parallelism`.
-    pub fn walkdir_new(root: impl AsRef<Path>, _: Parallelism) -> WalkDir {
+    pub fn walkdir_new(root: &Path, _: Parallelism) -> WalkDir {
         WalkDir::new(root)
     }
 
     /// Instantiate a new directory iterator which will not skip hidden files and is sorted, with the given level of `parallelism`.
-    pub fn walkdir_sorted_new(root: impl AsRef<Path>, _: Parallelism) -> WalkDir {
+    pub fn walkdir_sorted_new(root: &Path, _: Parallelism) -> WalkDir {
         WalkDir::new(root).sort_by_file_name()
     }
 

gix-features/src/hash.rs

@@ -95,14 +95,14 @@ pub fn hasher(kind: gix_hash::Kind) -> Sha1 {
 /// * [Interrupts][crate::interrupt] are supported.
 #[cfg(all(feature = "progress", any(feature = "rustsha1", feature = "fast-sha1")))]
 pub fn bytes_of_file(
-    path: impl AsRef<std::path::Path>,
+    path: &std::path::Path,
     num_bytes_from_start: usize,
     kind: gix_hash::Kind,
     progress: &mut impl crate::progress::Progress,
     should_interrupt: &std::sync::atomic::AtomicBool,
 ) -> std::io::Result<gix_hash::ObjectId> {
     bytes(
-        std::fs::File::open(path)?,
+        &mut std::fs::File::open(path)?,
         num_bytes_from_start,
         kind,
         progress,
@@ -113,7 +113,7 @@ pub fn bytes_of_file(
 /// Similar to [`bytes_of_file`], but operates on an already open file.
 #[cfg(all(feature = "progress", any(feature = "rustsha1", feature = "fast-sha1")))]
 pub fn bytes(
-    mut read: impl std::io::Read,
+    read: &mut dyn std::io::Read,
     num_bytes_from_start: usize,
     kind: gix_hash::Kind,
     progress: &mut impl crate::progress::Progress,

gix-features/src/io.rs

@@ -77,9 +77,9 @@ pub mod pipe {
     /// Returns the _([`write`][Writer], [`read`][Reader])_ ends of a pipe for transferring bytes, analogous to a unix pipe.
     ///
     /// * `in_flight_writes` defines the amount of chunks of bytes to keep in memory until the `write` end will block when writing.
-    ///    If `None` or `0`, the `write` end will always block until the `read` end consumes the transferred bytes.
-    pub fn unidirectional(in_flight_writes: impl Into<Option<usize>>) -> (Writer, Reader) {
-        let (tx, rx) = std::sync::mpsc::sync_channel(in_flight_writes.into().unwrap_or(0));
+    ///    If `0`, the `write` end will always block until the `read` end consumes the transferred bytes.
+    pub fn unidirectional(in_flight_writes: usize) -> (Writer, Reader) {
+        let (tx, rx) = std::sync::mpsc::sync_channel(in_flight_writes);
         (
             Writer {
                 channel: tx,

gix-features/tests/pipe.rs

@@ -22,7 +22,7 @@ mod io {
 
     #[test]
     fn lack_of_reader_fails_with_broken_pipe() {
-        let (mut writer, _) = io::pipe::unidirectional(None);
+        let (mut writer, _) = io::pipe::unidirectional(0);
         assert_eq!(
             writer.write_all(b"must fail").unwrap_err().kind(),
             ErrorKind::BrokenPipe
@@ -96,7 +96,7 @@ mod io {
     fn small_reads() {
         const BLOCK_SIZE: usize = 20;
         let block_count = 20;
-        let (mut writer, mut reader) = io::pipe::unidirectional(Some(4));
+        let (mut writer, mut reader) = io::pipe::unidirectional(4);
         std::thread::spawn(move || {
             for _ in 0..block_count {
                 let data = &[0; BLOCK_SIZE];