fix!: assure that rename tracking can be turned off.

Previously it was impossible to tell if rename tracking was disabled, or
if it was unset, which leads to incorrect logic.

This changes the signature of `diff::new_rewrites()` to also provide information about
whether or not it was configured.

Author: Byron

gix/src/config/cache/access.rs

@@ -156,7 +156,7 @@ impl Cache {
     }
 
     #[cfg(feature = "blob-diff")]
-    pub(crate) fn diff_renames(&self) -> Result<Option<gix_diff::Rewrites>, crate::diff::new_rewrites::Error> {
+    pub(crate) fn diff_renames(&self) -> Result<(Option<gix_diff::Rewrites>, bool), crate::diff::new_rewrites::Error> {
         self.diff_renames
             .get_or_try_init(|| crate::diff::new_rewrites(&self.resolved, self.lenient_config))
             .copied()

gix/src/config/mod.rs

@@ -605,7 +605,7 @@ pub(crate) struct Cache {
     pub(crate) url_rewrite: OnceCell<crate::remote::url::Rewrite>,
     /// The lazy-loaded rename information for diffs.
     #[cfg(feature = "blob-diff")]
-    pub(crate) diff_renames: OnceCell<Option<crate::diff::Rewrites>>,
+    pub(crate) diff_renames: OnceCell<(Option<crate::diff::Rewrites>, bool)>,
     /// A lazily loaded mapping to know which url schemes to allow
     #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
     pub(crate) url_scheme: OnceCell<crate::remote::url::SchemePermission>,

gix/src/diff.rs

@@ -51,7 +51,14 @@ impl Options {
     pub(crate) fn from_configuration(config: &crate::config::Cache) -> Result<Self, options::init::Error> {
         Ok(Options {
             location: Some(Location::Path),
-            rewrites: config.diff_renames()?.unwrap_or_default().into(),
+            rewrites: {
+                let (rewrites, is_configured) = config.diff_renames()?;
+                if is_configured {
+                    rewrites
+                } else {
+                    Some(Default::default())
+                }
+            },
         })
     }
 }
@@ -164,14 +171,14 @@ pub(crate) mod utils {
     }
 
     /// Create an instance by reading all relevant information from the `config`uration, while being `lenient` or not.
-    /// Returns `Ok(None)` if nothing is configured.
+    /// Returns `Ok((None, false))` if nothing is configured, or `Ok((None, true))` if it's configured and disabled.
     ///
     /// Note that missing values will be defaulted similar to what git does.
     #[allow(clippy::result_large_err)]
     pub fn new_rewrites(
         config: &gix_config::File<'static>,
         lenient: bool,
-    ) -> Result<Option<Rewrites>, new_rewrites::Error> {
+    ) -> Result<(Option<Rewrites>, bool), new_rewrites::Error> {
         new_rewrites_inner(config, lenient, &Diff::RENAMES, &Diff::RENAME_LIMIT)
     }
 
@@ -180,33 +187,36 @@ pub(crate) mod utils {
         lenient: bool,
         renames: &'static crate::config::tree::diff::Renames,
         rename_limit: &'static crate::config::tree::keys::UnsignedInteger,
-    ) -> Result<Option<Rewrites>, new_rewrites::Error> {
+    ) -> Result<(Option<Rewrites>, bool), new_rewrites::Error> {
         let copies = match config
             .boolean(renames)
             .map(|value| renames.try_into_renames(value))
             .transpose()
             .with_leniency(lenient)?
         {
             Some(renames) => match renames {
-                Tracking::Disabled => return Ok(None),
+                Tracking::Disabled => return Ok((None, true)),
                 Tracking::Renames => None,
                 Tracking::RenamesAndCopies => Some(Copies::default()),
             },
-            None => return Ok(None),
+            None => return Ok((None, false)),
         };
 
         let default = Rewrites::default();
-        Ok(Rewrites {
-            copies,
-            limit: config
-                .integer(rename_limit)
-                .map(|value| rename_limit.try_into_usize(value))
-                .transpose()
-                .with_leniency(lenient)?
-                .unwrap_or(default.limit),
-            ..default
-        }
-        .into())
+        Ok((
+            Rewrites {
+                copies,
+                limit: config
+                    .integer(rename_limit)
+                    .map(|value| rename_limit.try_into_usize(value))
+                    .transpose()
+                    .with_leniency(lenient)?
+                    .unwrap_or(default.limit),
+                ..default
+            }
+            .into(),
+            true,
+        ))
     }
 
     /// Return a low-level utility to efficiently prepare a blob-level diff operation between two resources,

gix/src/repository/merge.rs

@@ -88,21 +88,21 @@ impl Repository {
 
     /// Read all relevant configuration options to instantiate options for use in [`merge_trees()`](Self::merge_trees).
     pub fn tree_merge_options(&self) -> Result<crate::merge::tree::Options, tree_merge_options::Error> {
+        let (mut rewrites, mut is_configured) = crate::diff::utils::new_rewrites_inner(
+            &self.config.resolved,
+            self.config.lenient_config,
+            &tree::Merge::RENAMES,
+            &tree::Merge::RENAME_LIMIT,
+        )?;
+        if !is_configured {
+            (rewrites, is_configured) =
+                crate::diff::utils::new_rewrites(&self.config.resolved, self.config.lenient_config)?;
+        }
+        if !is_configured {
+            rewrites = Some(Default::default());
+        }
         Ok(gix_merge::tree::Options {
-            rewrites: Some(
-                crate::diff::utils::new_rewrites_inner(
-                    &self.config.resolved,
-                    self.config.lenient_config,
-                    &tree::Merge::RENAMES,
-                    &tree::Merge::RENAME_LIMIT,
-                )?
-                .map(Ok)
-                .or_else(|| {
-                    crate::diff::utils::new_rewrites(&self.config.resolved, self.config.lenient_config).transpose()
-                })
-                .transpose()?
-                .unwrap_or_default(),
-            ),
+            rewrites,
             blob_merge: self.blob_merge_options()?,
             blob_merge_command_ctx: self.command_context()?,
             fail_on_conflict: None,