fix(tail): Pass follow_name flag to watch_with_parent for correct behavior

The watch_with_parent method now considers both use_polling and follow_name:
- For --follow=name with inotify: watch parent directories
- For --follow=descriptor with inotify: watch files directly
- For any mode with polling: watch files directly

This ensures:
- --follow=name with inotify properly detects file modifications via parent directory events
- --follow=descriptor works correctly with both inotify and polling
- Polling mode always watches files directly for correct behavior

Fixed borrow checker errors by caching flags before mutable borrows.

Author: naoNao89

src/uu/tail/src/follow/watch.rs

@@ -33,19 +33,20 @@ impl WatcherRx {
     }
 
     /// Wrapper for `notify::Watcher::watch` to also add the parent directory of `path` if necessary.
-    /// When using polling, we watch the file directly; when using inotify, we watch the parent directory.
-    fn watch_with_parent(&mut self, path: &Path, #[cfg_attr(not(target_os = "linux"), allow(unused_variables))] use_polling: bool) -> UResult<()> {
+    /// When using polling OR --follow=descriptor, watch the file directly.
+    /// When using inotify with --follow=name, watch the parent directory.
+    fn watch_with_parent(&mut self, path: &Path, #[cfg_attr(not(target_os = "linux"), allow(unused_variables))] use_polling: bool, #[cfg_attr(not(target_os = "linux"), allow(unused_variables))] follow_name: bool) -> UResult<()> {
         let mut path = path.to_owned();
         #[cfg(target_os = "linux")]
-        if path.is_file() && !use_polling {
+        if path.is_file() && !use_polling && follow_name {
             /*
-            NOTE: Using the parent directory instead of the file is a workaround for inotify.
+            NOTE: Using the parent directory instead of the file is a workaround for inotify with --follow=name.
             This workaround follows the recommendation of the notify crate authors:
             > On some platforms, if the `path` is renamed or removed while being watched, behavior may
             > be unexpected. See discussions in [#165] and [#166]. If less surprising behavior is wanted
             > one may non-recursively watch the _parent_ directory as well and manage related events.
-            NOTE: This only applies to InotifyWatcher. PollWatcher sends events with the file path,
-            not the parent path, so we should watch the file directly when polling.
+            NOTE: This only applies to InotifyWatcher with --follow=name. For --follow=descriptor or
+            PollWatcher, we watch the file directly.
             */
             if let Some(parent) = path.parent() {
                 // clippy::assigning_clones added with Rust 1.78
@@ -276,6 +277,8 @@ impl Observer {
     }
 
     fn init_files(&mut self, inputs: &Vec<Input>) -> UResult<()> {
+        let use_polling = self.use_polling;
+        let follow_name = self.follow_name();
         if let Some(watcher_rx) = &mut self.watcher_rx {
             for input in inputs {
                 match input.kind() {
@@ -292,7 +295,7 @@ impl Observer {
 
                         if path.is_tailable() {
                             // Add existing regular files to `Watcher` (InotifyWatcher).
-                            watcher_rx.watch_with_parent(&path, self.use_polling)?;
+                            watcher_rx.watch_with_parent(&path, use_polling, follow_name)?;
                         } else if !path.is_orphan() {
                             // If `path` is not a tailable file, add its parent to `Watcher`.
                             watcher_rx
@@ -477,8 +480,10 @@ impl Observer {
                     );
 
                     // Unwatch old path and watch new path
+                    let use_polling = self.use_polling;
+                    let follow_name = self.follow_name();
                     let _ = self.watcher_rx.as_mut().unwrap().unwatch(event_path);
-                    self.watcher_rx.as_mut().unwrap().watch_with_parent(new_path, self.use_polling)?;
+                    self.watcher_rx.as_mut().unwrap().watch_with_parent(new_path, use_polling, follow_name)?;
                 }
             }
             _ => {}
@@ -525,11 +530,13 @@ pub fn follow(mut observer: Observer, settings: &Settings) -> UResult<()> {
                         observer.files.update_metadata(new_path, Some(md));
                         observer.files.update_reader(new_path)?;
                         _read_some = observer.files.tail_file(new_path, settings.verbose)?;
+                        let use_polling = observer.use_polling;
+                        let follow_name = observer.follow_name();
                         observer
                             .watcher_rx
                             .as_mut()
                             .unwrap()
-                            .watch_with_parent(new_path, observer.use_polling)?;
+                            .watch_with_parent(new_path, use_polling, follow_name)?;
                     }
                 }
             }