fix!: use dyn trait where possible.

This reduces compile time due to avoiding duplication.

Author: Byron

gix-config/src/file/access/comfort.rs

@@ -31,7 +31,8 @@ impl<'event> File<'event> {
         key: impl AsRef<str>,
         filter: &mut MetadataFilter,
     ) -> Option<Cow<'_, BStr>> {
-        self.raw_value_filter(section_name, subsection_name, key, filter).ok()
+        self.raw_value_filter(section_name.as_ref(), subsection_name, key.as_ref(), filter)
+            .ok()
     }
 
     /// Like [`string_filter()`][File::string_filter()], but suitable for statically known `key`s like `remote.origin.url`.
@@ -40,7 +41,7 @@ impl<'event> File<'event> {
         key: impl Into<&'a BStr>,
         filter: &mut MetadataFilter,
     ) -> Option<Cow<'_, BStr>> {
-        let key = crate::parse::key(key)?;
+        let key = crate::parse::key(key.into())?;
         self.raw_value_filter(key.section_name, key.subsection_name, key.value_name, filter)
             .ok()
     }
@@ -78,7 +79,7 @@ impl<'event> File<'event> {
         key: impl AsRef<str>,
         filter: &mut MetadataFilter,
     ) -> Option<crate::Path<'_>> {
-        self.raw_value_filter(section_name, subsection_name, key, filter)
+        self.raw_value_filter(section_name.as_ref(), subsection_name, key.as_ref(), filter)
             .ok()
             .map(crate::Path::from)
     }
@@ -89,7 +90,7 @@ impl<'event> File<'event> {
         key: impl Into<&'a BStr>,
         filter: &mut MetadataFilter,
     ) -> Option<crate::Path<'_>> {
-        let key = crate::parse::key(key)?;
+        let key = crate::parse::key(key.into())?;
         self.path_filter(key.section_name, key.subsection_name, key.value_name, filter)
     }
 
@@ -141,7 +142,7 @@ impl<'event> File<'event> {
         key: impl Into<&'a BStr>,
         filter: &mut MetadataFilter,
     ) -> Option<Result<bool, value::Error>> {
-        let key = crate::parse::key(key)?;
+        let key = crate::parse::key(key.into())?;
         self.boolean_filter(key.section_name, key.subsection_name, key.value_name, filter)
     }
 
@@ -168,7 +169,9 @@ impl<'event> File<'event> {
         key: impl AsRef<str>,
         filter: &mut MetadataFilter,
     ) -> Option<Result<i64, value::Error>> {
-        let int = self.raw_value_filter(section_name, subsection_name, key, filter).ok()?;
+        let int = self
+            .raw_value_filter(section_name.as_ref(), subsection_name, key.as_ref(), filter)
+            .ok()?;
         Some(crate::Integer::try_from(int.as_ref()).and_then(|b| {
             b.to_decimal()
                 .ok_or_else(|| value::Error::new("Integer overflow", int.into_owned()))
@@ -181,7 +184,7 @@ impl<'event> File<'event> {
         key: impl Into<&'a BStr>,
         filter: &mut MetadataFilter,
     ) -> Option<Result<i64, value::Error>> {
-        let key = crate::parse::key(key)?;
+        let key = crate::parse::key(key.into())?;
         self.integer_filter(key.section_name, key.subsection_name, key.value_name, filter)
     }
 
@@ -192,12 +195,13 @@ impl<'event> File<'event> {
         subsection_name: Option<&BStr>,
         key: impl AsRef<str>,
     ) -> Option<Vec<Cow<'_, BStr>>> {
-        self.raw_values(section_name, subsection_name, key).ok()
+        self.raw_values(section_name.as_ref(), subsection_name, key.as_ref())
+            .ok()
     }
 
     /// Like [`strings()`][File::strings()], but suitable for statically known `key`s like `remote.origin.url`.
     pub fn strings_by_key<'a>(&self, key: impl Into<&'a BStr>) -> Option<Vec<Cow<'_, BStr>>> {
-        let key = crate::parse::key(key)?;
+        let key = crate::parse::key(key.into())?;
         self.strings(key.section_name, key.subsection_name, key.value_name)
     }
 
@@ -209,7 +213,8 @@ impl<'event> File<'event> {
         key: impl AsRef<str>,
         filter: &mut MetadataFilter,
     ) -> Option<Vec<Cow<'_, BStr>>> {
-        self.raw_values_filter(section_name, subsection_name, key, filter).ok()
+        self.raw_values_filter(section_name.as_ref(), subsection_name, key.as_ref(), filter)
+            .ok()
     }
 
     /// Like [`strings_filter()`][File::strings_filter()], but suitable for statically known `key`s like `remote.origin.url`.
@@ -218,7 +223,7 @@ impl<'event> File<'event> {
         key: impl Into<&'a BStr>,
         filter: &mut MetadataFilter,
     ) -> Option<Vec<Cow<'_, BStr>>> {
-        let key = crate::parse::key(key)?;
+        let key = crate::parse::key(key.into())?;
         self.strings_filter(key.section_name, key.subsection_name, key.value_name, filter)
     }
 
@@ -247,7 +252,7 @@ impl<'event> File<'event> {
         key: impl AsRef<str>,
         filter: &mut MetadataFilter,
     ) -> Option<Result<Vec<i64>, value::Error>> {
-        self.raw_values_filter(section_name, subsection_name, key, filter)
+        self.raw_values_filter(section_name.as_ref(), subsection_name, key.as_ref(), filter)
             .ok()
             .map(|values| {
                 values
@@ -268,7 +273,7 @@ impl<'event> File<'event> {
         key: impl Into<&'a BStr>,
         filter: &mut MetadataFilter,
     ) -> Option<Result<Vec<i64>, value::Error>> {
-        let key = crate::parse::key(key)?;
+        let key = crate::parse::key(key.into())?;
         self.integers_filter(key.section_name, key.subsection_name, key.value_name, filter)
     }
 }

gix-config/src/file/access/mutate.rs

@@ -15,7 +15,7 @@ impl<'event> File<'event> {
     /// Returns the last mutable section with a given `name` and optional `subsection_name`, _if it exists_.
     pub fn section_mut<'a>(
         &'a mut self,
-        name: impl AsRef<str>,
+        name: &str,
         subsection_name: Option<&BStr>,
     ) -> Result<SectionMut<'a, 'event>, lookup::existing::Error> {
         let id = self
@@ -31,10 +31,7 @@ impl<'event> File<'event> {
     }
 
     /// Returns the last found mutable section with a given `key`, identifying the name and subsection name like `core` or `remote.origin`.
-    pub fn section_mut_by_key<'a, 'b>(
-        &'a mut self,
-        key: impl Into<&'b BStr>,
-    ) -> Result<SectionMut<'a, 'event>, lookup::existing::Error> {
+    pub fn section_mut_by_key<'a>(&'a mut self, key: &BStr) -> Result<SectionMut<'a, 'event>, lookup::existing::Error> {
         let key = section::unvalidated::Key::parse(key).ok_or(lookup::existing::Error::KeyMissing)?;
         self.section_mut(key.section_name, key.subsection_name)
     }
@@ -50,7 +47,7 @@ impl<'event> File<'event> {
     /// Returns the last mutable section with a given `name` and optional `subsection_name`, _if it exists_, or create a new section.
     pub fn section_mut_or_create_new<'a>(
         &'a mut self,
-        name: impl AsRef<str>,
+        name: &str,
         subsection_name: Option<&BStr>,
     ) -> Result<SectionMut<'a, 'event>, section::header::Error> {
         self.section_mut_or_create_new_filter(name, subsection_name, &mut |_| true)
@@ -60,11 +57,10 @@ impl<'event> File<'event> {
     /// a new section.
     pub fn section_mut_or_create_new_filter<'a>(
         &'a mut self,
-        name: impl AsRef<str>,
+        name: &str,
         subsection_name: Option<&BStr>,
         filter: &mut MetadataFilter,
     ) -> Result<SectionMut<'a, 'event>, section::header::Error> {
-        let name = name.as_ref();
         match self
             .section_ids_by_name_and_subname(name.as_ref(), subsection_name)
             .ok()
@@ -82,7 +78,10 @@ impl<'event> File<'event> {
                     .expect("BUG: Section did not have id from lookup")
                     .to_mut(nl))
             }
-            None => self.new_section(name.to_owned(), subsection_name.map(|n| Cow::Owned(n.to_owned()))),
+            None => self.new_section(
+                name.to_owned().into(),
+                subsection_name.map(|n| Cow::Owned(n.to_owned())),
+            ),
         }
     }
 
@@ -92,7 +91,7 @@ impl<'event> File<'event> {
     /// is returned.
     pub fn section_mut_filter<'a>(
         &'a mut self,
-        name: impl AsRef<str>,
+        name: &str,
         subsection_name: Option<&BStr>,
         filter: &mut MetadataFilter,
     ) -> Result<Option<file::SectionMut<'a, 'event>>, lookup::existing::Error> {
@@ -109,9 +108,9 @@ impl<'event> File<'event> {
 
     /// Like [`section_mut_filter()`][File::section_mut_filter()], but identifies the with a given `key`,
     /// like `core` or `remote.origin`.
-    pub fn section_mut_filter_by_key<'a, 'b>(
+    pub fn section_mut_filter_by_key<'a>(
         &'a mut self,
-        key: impl Into<&'b BStr>,
+        key: &BStr,
         filter: &mut MetadataFilter,
     ) -> Result<Option<file::SectionMut<'a, 'event>>, lookup::existing::Error> {
         let key = section::unvalidated::Key::parse(key).ok_or(lookup::existing::Error::KeyMissing)?;
@@ -131,7 +130,7 @@ impl<'event> File<'event> {
     /// # use gix_config::File;
     /// # use std::convert::TryFrom;
     /// let mut git_config = gix_config::File::default();
-    /// let section = git_config.new_section("hello", Some(Cow::Borrowed("world".into())))?;
+    /// let section = git_config.new_section("hello".into(), Some(Cow::Borrowed("world".into())))?;
     /// let nl = section.newline().to_owned();
     /// assert_eq!(git_config.to_string(), format!("[hello \"world\"]{nl}"));
     /// # Ok::<(), Box<dyn std::error::Error>>(())
@@ -146,18 +145,18 @@ impl<'event> File<'event> {
     /// # use bstr::ByteSlice;
     /// # use gix_config::parse::section;
     /// let mut git_config = gix_config::File::default();
-    /// let mut section = git_config.new_section("hello", Some(Cow::Borrowed("world".into())))?;
+    /// let mut section = git_config.new_section("hello".into(), Some(Cow::Borrowed("world".into())))?;
     /// section.push(section::Key::try_from("a")?, Some("b".into()));
     /// let nl = section.newline().to_owned();
     /// assert_eq!(git_config.to_string(), format!("[hello \"world\"]{nl}\ta = b{nl}"));
-    /// let _section = git_config.new_section("core", None);
+    /// let _section = git_config.new_section("core".into(), None);
     /// assert_eq!(git_config.to_string(), format!("[hello \"world\"]{nl}\ta = b{nl}[core]{nl}"));
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     pub fn new_section(
         &mut self,
-        name: impl Into<Cow<'event, str>>,
-        subsection: impl Into<Option<Cow<'event, BStr>>>,
+        name: Cow<'event, str>,
+        subsection: Option<Cow<'event, BStr>>,
     ) -> Result<SectionMut<'_, 'event>, section::header::Error> {
         let id = self.push_section_internal(file::Section::new(name, subsection, OwnShared::clone(&self.meta))?);
         let nl = self.detect_newline_style_smallvec();
@@ -203,11 +202,7 @@ impl<'event> File<'event> {
     /// assert_eq!(git_config.to_string(), "[hello \"world\"]\n    some-value = 4\n");
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
-    pub fn remove_section<'a>(
-        &mut self,
-        name: &str,
-        subsection_name: impl Into<Option<&'a BStr>>,
-    ) -> Option<file::Section<'event>> {
+    pub fn remove_section(&mut self, name: &str, subsection_name: Option<&BStr>) -> Option<file::Section<'event>> {
         let id = self
             .section_ids_by_name_and_subname(name, subsection_name.into())
             .ok()?
@@ -252,10 +247,10 @@ impl<'event> File<'event> {
     /// if at least one section matched the `filter`.
     /// If multiple sections have the same name, then the last one is returned. Note that
     /// later sections with the same name have precedent over earlier ones.
-    pub fn remove_section_filter<'a>(
+    pub fn remove_section_filter(
         &mut self,
         name: &str,
-        subsection_name: impl Into<Option<&'a BStr>>,
+        subsection_name: Option<&BStr>,
         filter: &mut MetadataFilter,
     ) -> Option<file::Section<'event>> {
         let id = self
@@ -283,12 +278,12 @@ impl<'event> File<'event> {
 
     /// Renames the section with `name` and `subsection_name`, modifying the last matching section
     /// to use `new_name` and `new_subsection_name`.
-    pub fn rename_section<'a>(
+    pub fn rename_section(
         &mut self,
-        name: impl AsRef<str>,
-        subsection_name: impl Into<Option<&'a BStr>>,
-        new_name: impl Into<Cow<'event, str>>,
-        new_subsection_name: impl Into<Option<Cow<'event, BStr>>>,
+        name: &str,
+        subsection_name: Option<&BStr>,
+        new_name: Cow<'event, str>,
+        new_subsection_name: Option<Cow<'event, BStr>>,
     ) -> Result<(), rename_section::Error> {
         let id = self
             .section_ids_by_name_and_subname(name.as_ref(), subsection_name.into())?
@@ -304,12 +299,12 @@ impl<'event> File<'event> {
     ///
     /// Note that the otherwise unused [`lookup::existing::Error::KeyMissing`] variant is used to indicate
     /// that the `filter` rejected all candidates, leading to no section being renamed after all.
-    pub fn rename_section_filter<'a>(
+    pub fn rename_section_filter(
         &mut self,
-        name: impl AsRef<str>,
-        subsection_name: impl Into<Option<&'a BStr>>,
-        new_name: impl Into<Cow<'event, str>>,
-        new_subsection_name: impl Into<Option<Cow<'event, BStr>>>,
+        name: &str,
+        subsection_name: Option<&BStr>,
+        new_name: Cow<'event, str>,
+        new_subsection_name: Option<Cow<'event, BStr>>,
         filter: &mut MetadataFilter,
     ) -> Result<(), rename_section::Error> {
         let id = self