fix!: use dyn trait where possible.

This reduces compile time due to avoiding duplication.

Author: Byron

gix/src/clone/checkout.rs

@@ -26,10 +26,7 @@ pub mod main_worktree {
         #[error(transparent)]
         CheckoutOptions(#[from] crate::config::checkout_options::Error),
         #[error(transparent)]
-        IndexCheckout(
-            #[from]
-            gix_worktree_state::checkout::Error<gix_odb::find::existing_object::Error<gix_odb::store::find::Error>>,
-        ),
+        IndexCheckout(#[from] gix_worktree_state::checkout::Error<gix_odb::find::existing_object::Error>),
         #[error("Failed to reopen object database as Arc (only if thread-safety wasn't compiled in)")]
         OpenArcOdb(#[from] std::io::Error),
         #[error("The HEAD reference could not be located")]

gix/src/clone/mod.rs

@@ -89,16 +89,22 @@ impl PrepareFetch {
                 .set_raw_value(
                     "gitoxide",
                     Some("committer".into()),
-                    gitoxide::Committer::NAME_FALLBACK.name,
-                    "no name configured during clone",
+                    gitoxide::Committer::NAME_FALLBACK
+                        .name
+                        .try_into()
+                        .expect("compile time"),
+                    "no name configured during clone".into(),
                 )
                 .expect("works - statically known");
             config
                 .set_raw_value(
                     "gitoxide",
                     Some("committer".into()),
-                    gitoxide::Committer::EMAIL_FALLBACK.name,
-                    "noEmailAvailable@example.com",
+                    gitoxide::Committer::EMAIL_FALLBACK
+                        .name
+                        .try_into()
+                        .expect("compile time"),
+                    "noEmailAvailable@example.com".into(),
                 )
                 .expect("works - statically known");
             let mut repo_config = repo.config_snapshot_mut();

gix/src/commit.rs

@@ -204,7 +204,7 @@ pub mod describe {
                         .try_find(id, buf)
                         .map(|r| r.and_then(gix_object::Data::try_into_commit_iter))
                 },
-                gix_commitgraph::Graph::from_info_dir(self.repo.objects.store_ref().path().join("info")).ok(),
+                gix_commitgraph::Graph::from_info_dir(self.repo.objects.store_ref().path().join("info").as_ref()).ok(),
             );
             let outcome = gix_revision::describe(
                 &self.id,

gix/src/config/cache/init.rs

@@ -72,7 +72,7 @@ impl Cache {
 
         let config = {
             let git_prefix = &git_prefix;
-            let metas = [
+            let mut metas = [
                 gix_config::source::Kind::GitInstallation,
                 gix_config::source::Kind::System,
                 gix_config::source::Kind::Global,
@@ -100,7 +100,7 @@ impl Cache {
 
             let err_on_nonexisting_paths = false;
             let mut globals = gix_config::File::from_paths_metadata_buf(
-                metas,
+                &mut metas,
                 &mut buf,
                 err_on_nonexisting_paths,
                 gix_config::file::init::Options {
@@ -491,7 +491,7 @@ fn apply_environment_overrides(
         ),
     ] {
         let mut section = env_override
-            .new_section(section_name, subsection_name)
+            .new_section(section_name.into(), subsection_name)
             .expect("statically known valid section name");
         for (var, key) in data {
             if let Some(value) = var_as_bstring(var, permission) {
@@ -510,7 +510,7 @@ fn apply_environment_overrides(
 
     {
         let mut section = env_override
-            .new_section("core", None)
+            .new_section("core".into(), None)
             .expect("statically known valid section name");
 
         for (var, key, permission) in [

gix/src/config/overrides.rs

@@ -29,8 +29,12 @@ pub(crate) fn append(
         let mut tokens = key_value.splitn(2, |b| *b == b'=').map(ByteSlice::trim);
         let key = tokens.next().expect("always one value").as_bstr();
         let value = tokens.next();
-        let key = gix_config::parse::key(key.to_str().map_err(|_| Error::InvalidKey { input: key.into() })?)
-            .ok_or_else(|| Error::InvalidKey { input: key.into() })?;
+        let key = gix_config::parse::key(
+            key.to_str()
+                .map_err(|_| Error::InvalidKey { input: key.into() })?
+                .into(),
+        )
+        .ok_or_else(|| Error::InvalidKey { input: key.into() })?;
         let mut section = file.section_mut_or_create_new(key.section_name, key.subsection_name)?;
         let key =
             gix_config::parse::section::Key::try_from(key.value_name.to_owned()).map_err(|err| Error::SectionKey {

gix/src/config/snapshot/access.rs

@@ -3,6 +3,7 @@ use std::borrow::Cow;
 
 use gix_features::threading::OwnShared;
 
+use crate::bstr::ByteSlice;
 use crate::{
     bstr::{BStr, BString},
     config::{CommitAutoRollback, Snapshot, SnapshotMut},
@@ -58,7 +59,7 @@ impl<'repo> Snapshot<'repo> {
         &self,
         key: impl Into<&'a BStr>,
     ) -> Option<Result<Cow<'_, std::path::Path>, gix_config::path::interpolate::Error>> {
-        let key = gix_config::parse::key(key)?;
+        let key = gix_config::parse::key(key.into())?;
         self.repo
             .config
             .trusted_file_path(key.section_name, key.subsection_name, key.value_name)
@@ -111,9 +112,12 @@ impl<'repo> SnapshotMut<'repo> {
         }
         let value = new_value.into();
         key.validate(value)?;
-        let current = self
-            .config
-            .set_raw_value(key.section().name(), None, key.name(), value)?;
+        let current = self.config.set_raw_value(
+            key.section().name(),
+            None,
+            key.name().try_into().expect("compile time"),
+            value,
+        )?;
         Ok(current.map(std::borrow::Cow::into_owned))
     }
 
@@ -134,10 +138,13 @@ impl<'repo> SnapshotMut<'repo> {
         let name = key
             .full_name(Some(subsection.into()))
             .expect("we know it needs a subsection");
-        let key = gix_config::parse::key(&**name).expect("statically known keys can always be parsed");
-        let current =
-            self.config
-                .set_raw_value(key.section_name, key.subsection_name, key.value_name.to_owned(), value)?;
+        let key = gix_config::parse::key((&**name).as_bstr()).expect("statically known keys can always be parsed");
+        let current = self.config.set_raw_value(
+            key.section_name,
+            key.subsection_name,
+            key.value_name.to_owned().try_into().expect("compile time"),
+            value,
+        )?;
         Ok(current.map(std::borrow::Cow::into_owned))
     }
 

gix/src/create.rs

@@ -207,7 +207,7 @@ pub fn into(
         let mut config = gix_config::File::default();
         {
             let caps = fs_capabilities.unwrap_or_else(|| gix_fs::Capabilities::probe(&dot_git));
-            let mut core = config.new_section("core", None).expect("valid section name");
+            let mut core = config.new_section("core".into(), None).expect("valid section name");
 
             core.push(key("repositoryformatversion"), Some("0".into()));
             core.push(key("filemode"), Some(bool(caps.executable_bit).into()));
@@ -232,7 +232,7 @@ pub fn into(
         } else {
             gix_discover::repository::Kind::WorkTree { linked_git_dir: None }
         },
-        std::env::current_dir()?,
+        &std::env::current_dir()?,
     )
     .expect("by now the `dot_git` dir is valid as we have accessed it"))
 }

gix/src/discover.rs

@@ -37,7 +37,7 @@ impl ThreadSafeRepository {
         trust_map: gix_sec::trust::Mapping<crate::open::Options>,
     ) -> Result<Self, Error> {
         let _span = gix_trace::coarse!("ThreadSafeRepository::discover()");
-        let (path, trust) = upwards_opts(directory, options)?;
+        let (path, trust) = upwards_opts(directory.as_ref(), options)?;
         let (git_dir, worktree_dir) = path.into_repository_and_work_tree_directories();
         let mut options = trust_map.into_value_by_level(trust);
         options.git_dir_trust = trust.into();

gix/src/filter.rs

@@ -147,15 +147,15 @@ impl<'repo> Pipeline<'repo> {
         Ok(self.inner.convert_to_git(
             src,
             rela_path,
-            |_, attrs| {
+            &mut |_, attrs| {
                 entry.matching_attributes(attrs);
             },
-            |rela_path, buf| -> Result<_, crate::object::find::Error> {
+            &mut |rela_path, buf| -> Result<_, crate::object::find::Error> {
                 let entry = match index.entry_by_path(rela_path) {
                     None => return Ok(None),
                     Some(entry) => entry,
                 };
-                let obj = self.repo.objects.try_find(entry.id, buf)?;
+                let obj = self.repo.objects.try_find(&entry.id, buf)?;
                 Ok(obj.filter(|obj| obj.kind == gix_object::Kind::Blob).map(|_| ()))
             },
         )?)
@@ -181,7 +181,7 @@ impl<'repo> Pipeline<'repo> {
         Ok(self.inner.convert_to_worktree(
             src,
             rela_path,
-            |_, attrs| {
+            &mut |_, attrs| {
                 entry.matching_attributes(attrs);
             },
             can_delay,

gix/src/object/errors.rs

@@ -18,17 +18,17 @@ pub mod conversion {
 ///
 pub mod find {
     /// Indicate that an error occurred when trying to find an object.
-    pub type Error = gix_odb::store::find::Error;
+    pub type Error = gix_odb::find::Error;
 
     ///
     pub mod existing {
         /// An object could not be found in the database, or an error occurred when trying to obtain it.
-        pub type Error = gix_odb::find::existing::Error<gix_odb::store::find::Error>;
+        pub type Error = gix_odb::find::existing::Error;
     }
 }
 
 ///
 pub mod write {
     /// An error to indicate writing to the loose object store failed.
-    pub type Error = gix_odb::store::write::Error;
+    pub type Error = gix_odb::write::Error;
 }

gix/src/object/tree/mod.rs

@@ -71,7 +71,7 @@ impl<'repo> Tree<'repo> {
                         }));
                     } else {
                         let next_id = entry.oid.to_owned();
-                        let obj = self.repo.objects.find(next_id, buf)?;
+                        let obj = self.repo.objects.find(&next_id, buf)?;
                         if !obj.kind.is_tree() {
                             return Ok(None);
                         }
@@ -113,7 +113,7 @@ impl<'repo> Tree<'repo> {
                         }));
                     } else {
                         let next_id = entry.oid.to_owned();
-                        let obj = self.repo.objects.find(next_id, &mut self.data)?;
+                        let obj = self.repo.objects.find(&next_id, &mut self.data)?;
                         self.id = next_id;
                         if !obj.kind.is_tree() {
                             return Ok(None);

gix/src/open/repository.rs

@@ -176,7 +176,7 @@ impl ThreadSafeRepository {
         //       This would be something read in later as have to first check for extensions. Also this means
         //       that each worktree, even if accessible through this instance, has to come in its own Repository instance
         //       as it may have its own configuration. That's fine actually.
-        let common_dir = gix_discover::path::from_plain_file(git_dir.join("commondir"))
+        let common_dir = gix_discover::path::from_plain_file(git_dir.join("commondir").as_ref())
             .transpose()?
             .map(|cd| git_dir.join(cd));
         let common_dir_ref = common_dir.as_deref().unwrap_or(&git_dir);
@@ -192,8 +192,10 @@ impl ThreadSafeRepository {
             let reflog = repo_config.reflog.unwrap_or(gix_ref::store::WriteReflog::Disable);
             let object_hash = repo_config.object_hash;
             match &common_dir {
-                Some(common_dir) => crate::RefStore::for_linked_worktree(&git_dir, common_dir, reflog, object_hash),
-                None => crate::RefStore::at(&git_dir, reflog, object_hash),
+                Some(common_dir) => {
+                    crate::RefStore::for_linked_worktree(git_dir.to_owned(), common_dir.into(), reflog, object_hash)
+                }
+                None => crate::RefStore::at(git_dir.to_owned(), reflog, object_hash),
             }
         };
         let head = refs.find("HEAD").ok();
@@ -236,7 +238,7 @@ impl ThreadSafeRepository {
                     .interpolate(interpolate_context(git_install_dir.as_deref(), home.as_deref()))
                     .map_err(config::Error::PathInterpolation)?;
                 worktree_dir = {
-                    gix_path::normalize(git_dir.join(wt_path), current_dir)
+                    gix_path::normalize(git_dir.join(wt_path).into(), current_dir)
                         .and_then(|wt| wt.as_ref().is_dir().then(|| wt.into_owned()))
                 }
             }
@@ -276,7 +278,7 @@ impl ThreadSafeRepository {
         Ok(ThreadSafeRepository {
             objects: OwnShared::new(gix_odb::Store::at_opts(
                 common_dir_ref.join("objects"),
-                replacements,
+                &mut replacements.into_iter(),
                 gix_odb::store::init::Options {
                     slots: object_store_slots,
                     object_hash: config.object_hash,

gix/src/reference/iter.rs

@@ -43,31 +43,31 @@ impl<'r> Platform<'r> {
     // TODO: Create a custom `Path` type that enforces the requirements of git naturally, this type is surprising possibly on windows
     //       and when not using a trailing '/' to signal directories.
     pub fn prefixed(&self, prefix: impl AsRef<Path>) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed(prefix)?))
+        Ok(Iter::new(self.repo, self.platform.prefixed(prefix.as_ref())?))
     }
 
     // TODO: tests
     /// Return an iterator over all references that are tags.
     ///
     /// They are all prefixed with `refs/tags`.
     pub fn tags(&self) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed("refs/tags/")?))
+        Ok(Iter::new(self.repo, self.platform.prefixed("refs/tags/".as_ref())?))
     }
 
     // TODO: tests
     /// Return an iterator over all local branches.
     ///
     /// They are all prefixed with `refs/heads`.
     pub fn local_branches(&self) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed("refs/heads/")?))
+        Ok(Iter::new(self.repo, self.platform.prefixed("refs/heads/".as_ref())?))
     }
 
     // TODO: tests
     /// Return an iterator over all remote branches.
     ///
     /// They are all prefixed with `refs/remotes`.
     pub fn remote_branches(&self) -> Result<Iter<'_>, init::Error> {
-        Ok(Iter::new(self.repo, self.platform.prefixed("refs/remotes/")?))
+        Ok(Iter::new(self.repo, self.platform.prefixed("refs/remotes/".as_ref())?))
     }
 }
 
@@ -95,10 +95,10 @@ impl<'r> Iterator for Iter<'r> {
                 .and_then(|mut r| {
                     if self.peel {
                         let handle = &self.repo;
-                        r.peel_to_id_in_place(&handle.refs, |oid, buf| {
+                        r.peel_to_id_in_place(&handle.refs, &mut |oid, buf| {
                             handle
                                 .objects
-                                .try_find(oid, buf)
+                                .try_find(oid.as_ref(), buf)
                                 .map(|po| po.map(|(o, _l)| (o.kind, o.data)))
                         })
                         .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync + 'static>)

gix/src/reference/mod.rs

@@ -70,9 +70,9 @@ impl<'repo> Reference<'repo> {
     /// This is useful to learn where this reference is ultimately pointing to.
     pub fn peel_to_id_in_place(&mut self) -> Result<Id<'repo>, peel::Error> {
         let repo = &self.repo;
-        let oid = self.inner.peel_to_id_in_place(&repo.refs, |oid, buf| {
+        let oid = self.inner.peel_to_id_in_place(&repo.refs, &mut |oid, buf| {
             repo.objects
-                .try_find(oid, buf)
+                .try_find(&oid, buf)
                 .map(|po| po.map(|(o, _l)| (o.kind, o.data)))
         })?;
         Ok(Id::from_id(oid, repo))

gix/src/repository/object.rs

@@ -32,7 +32,7 @@ impl crate::Repository {
             });
         }
         let mut buf = self.free_buf();
-        let kind = self.objects.find(id, &mut buf)?.kind;
+        let kind = self.objects.find(&id, &mut buf)?.kind;
         Ok(Object::from_data(id, kind, buf, self))
     }
 
@@ -65,7 +65,7 @@ impl crate::Repository {
                 size: 0,
             }));
         }
-        self.objects.try_header(id)
+        self.objects.try_header(&id)
     }
 
     /// Try to find the object with `id` or return `None` if it wasn't found.
@@ -81,7 +81,7 @@ impl crate::Repository {
         }
 
         let mut buf = self.free_buf();
-        match self.objects.try_find(id, &mut buf)? {
+        match self.objects.try_find(&id, &mut buf)? {
             Some(obj) => {
                 let kind = obj.kind;
                 Ok(Some(Object::from_data(id, kind, buf, self)))
@@ -111,7 +111,7 @@ impl crate::Repository {
         object.write_to(buf.deref_mut())?;
 
         let oid = gix_object::compute_hash(self.object_hash(), object.kind(), &buf);
-        if self.objects.contains(oid) {
+        if self.objects.contains(&oid) {
             return Ok(oid.attach(self));
         }
 
@@ -128,7 +128,7 @@ impl crate::Repository {
     pub fn write_blob(&self, bytes: impl AsRef<[u8]>) -> Result<Id<'_>, object::write::Error> {
         let bytes = bytes.as_ref();
         let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, bytes);
-        if self.objects.contains(oid) {
+        if self.objects.contains(&oid) {
             return Ok(oid.attach(self));
         }
         self.objects
@@ -149,7 +149,7 @@ impl crate::Repository {
         let mut buf = self.shared_empty_buf();
         std::io::copy(&mut bytes, buf.deref_mut())?;
         let oid = gix_object::compute_hash(self.object_hash(), gix_object::Kind::Blob, &buf);
-        if self.objects.contains(oid) {
+        if self.objects.contains(&oid) {
             return Ok(oid.attach(self));
         }