fix: if core.symlinks=false, don't misclassify actual symlinks as files.

Thus, prefer the actual observation over the stored and maybe incorrect filesystem settings.
This avoids false-positives when checking for changes.

Author: Byron

gix-status/src/index_as_worktree/function.rs

@@ -408,12 +408,12 @@ impl<'index> State<'_, 'index> {
                 None => false,
             };
 
-        // Here we implement racy-git. See racy-git.txt in the git documentation for a detailed documentation.
+        // We implement racy-git. See racy-git.txt in the git documentation for detailed documentation.
         //
         // A file is racy if:
-        // 1. its `mtime` is at or after the last index timestamp and its entry stat information
-        //   matches the on-disk file but the file contents are actually modified
-        // 2. it's size is 0 (set after detecting a file was racy previously)
+        // 1. Its `mtime` is at or after the last index timestamp and its entry stat information
+        //   matches the on-disk file, but the file contents are actually modified
+        // 2. Its size is 0 (set after detecting a file was racy previously)
         //
         // The first case is detected below by checking the timestamp if the file is marked unmodified.
         // The second case is usually detected either because the on-disk file is not empty, hence
@@ -449,7 +449,16 @@ impl<'index> State<'_, 'index> {
             file_len: file_size_bytes,
             filter: &mut self.filter,
             attr_stack: &mut self.attr_stack,
-            options: self.options,
+            core_symlinks:
+            // If this is legitimately a symlink, then pretend symlinks are enabled as the option seems stale.
+            // Otherwise, respect the option.
+            if metadata.is_symlink()
+                && entry.mode.to_tree_entry_mode().map(|m| m.kind()) == Some(gix_object::tree::EntryKind::Link)
+            {
+                true
+            } else {
+                self.options.fs.symlink
+            },
             id: &entry.id,
             objects,
             worktree_reads: self.worktree_reads,
@@ -517,7 +526,7 @@ where
     entry: &'a gix_index::Entry,
     filter: &'a mut gix_filter::Pipeline,
     attr_stack: &'a mut gix_worktree::Stack,
-    options: &'a Options,
+    core_symlinks: bool,
     id: &'a gix_hash::oid,
     objects: Find,
     worktree_bytes: &'a AtomicU64,
@@ -545,7 +554,7 @@ where
         //
         let is_symlink = self.entry.mode == gix_index::entry::Mode::SYMLINK;
         // TODO: what to do about precompose unicode and ignore_case for symlinks
-        let out = if is_symlink && self.options.fs.symlink {
+        let out = if is_symlink && self.core_symlinks {
             // conversion to bstr can never fail because symlinks are only used
             // on unix (by git) so no reason to use the try version here
             let symlink_path =

gix-status/tests/status/index_as_worktree.rs

@@ -48,6 +48,7 @@ fn nonfile_fixture(name: &str, expected_status: &[Expectation<'_>]) -> Outcome {
         false,
         Default::default(),
         false,
+        None,
     )
 }
 
@@ -65,6 +66,7 @@ fn fixture_with_index(
         false,
         Default::default(),
         false,
+        None,
     )
 }
 
@@ -78,6 +80,7 @@ fn submodule_fixture(name: &str, expected_status: &[Expectation<'_>]) -> Outcome
         false,
         Default::default(),
         false,
+        None,
     )
 }
 
@@ -91,6 +94,7 @@ fn conflict_fixture(name: &str, expected_status: &[Expectation<'_>]) -> Outcome
         false,
         Default::default(),
         false,
+        None,
     )
 }
 
@@ -104,6 +108,7 @@ fn submodule_fixture_status(name: &str, expected_status: &[Expectation<'_>], sub
         submodule_dirty,
         Default::default(),
         false,
+        None,
     )
 }
 
@@ -117,6 +122,7 @@ fn fixture_filtered(name: &str, pathspecs: &[&str], expected_status: &[Expectati
         false,
         Default::default(),
         false,
+        None,
     )
 }
 
@@ -130,6 +136,7 @@ fn fixture_filtered_detailed(
     submodule_dirty: bool,
     auto_crlf: gix_filter::eol::AutoCrlf,
     use_odb: bool,
+    fs_capabilities: Option<&dyn Fn(&std::path::Path) -> gix_fs::Capabilities>,
 ) -> Outcome {
     // This can easily happen in some fixtures, which can cause flakiness. It's time-dependent after all.
     fn ignore_racyclean(mut out: Outcome) -> Outcome {
@@ -179,7 +186,7 @@ fn fixture_filtered_detailed(
         should_interrupt: &AtomicBool::default(),
     };
     let options = Options {
-        fs: gix_fs::Capabilities::probe(&git_dir),
+        fs: fs_capabilities.map_or_else(|| gix_fs::Capabilities::probe(&git_dir), |new| new(&git_dir)),
         stat: TEST_OPTIONS,
         ..Options::default()
     };
@@ -353,6 +360,7 @@ fn replace_dir_with_file() {
         false,
         Default::default(),
         false,
+        None,
     );
     assert_eq!(
         out,
@@ -560,6 +568,24 @@ fn unchanged() {
     fixture("status_unchanged", &[]);
 }
 
+#[test]
+fn unchanged_symlinks_present_but_deactivated() {
+    fixture_filtered_detailed(
+        "status_unchanged",
+        "",
+        &[],
+        &[],
+        |_| {},
+        false,
+        Default::default(),
+        false,
+        Some(&|dir| gix_fs::Capabilities {
+            symlink: false,
+            ..gix_fs::Capabilities::probe(dir)
+        }),
+    );
+}
+
 #[test]
 fn unchanged_despite_filter() {
     let actual_outcome = fixture_filtered_detailed(
@@ -571,6 +597,7 @@ fn unchanged_despite_filter() {
         false,
         AutoCrlf::Enabled,
         true, /* make ODB available */
+        None,
     );
 
     let expected_outcome = Outcome {