feat(mv): add symlink handling in mv operations

- Modified HardlinkGroupScanner to skip symlinks using symlink_metadata, as hardlink preservation does not apply to them
- Added copy_symlink functions for Unix, Windows, and other platforms to copy symlinks without dereferencing
- Updated copy_dir_contents_recursive to detect and copy symlinks, including verbose output, preventing dereferencing during directory moves

Author: mattsu2020

src/uu/mv/src/hardlink.rs

@@ -217,18 +217,23 @@ impl HardlinkGroupScanner {
     fn scan_single_path(&mut self, path: &Path) -> io::Result<()> {
         use std::os::unix::fs::MetadataExt;
 
-        if path.is_dir() {
+        let metadata = path.symlink_metadata()?;
+        let file_type = metadata.file_type();
+
+        if file_type.is_symlink() {
+            // Hardlink preservation does not apply to symlinks.
+            return Ok(());
+        }
+
+        if file_type.is_dir() {
             // Recursively scan directory contents
             self.scan_directory_recursive(path)?;
-        } else {
-            let metadata = path.metadata()?;
-            if metadata.nlink() > 1 {
-                let key = (metadata.dev(), metadata.ino());
-                self.hardlink_groups
-                    .entry(key)
-                    .or_default()
-                    .push(path.to_path_buf());
-            }
+        } else if metadata.nlink() > 1 {
+            let key = (metadata.dev(), metadata.ino());
+            self.hardlink_groups
+                .entry(key)
+                .or_default()
+                .push(path.to_path_buf());
         }
         Ok(())
     }
@@ -242,14 +247,19 @@ impl HardlinkGroupScanner {
             let entry = entry?;
             let path = entry.path();
 
-            if path.is_dir() {
+            let metadata = path.symlink_metadata()?;
+            let file_type = metadata.file_type();
+
+            if file_type.is_symlink() {
+                // Skip symlinks to avoid following targets (including dangling links).
+                continue;
+            }
+
+            if file_type.is_dir() {
                 self.scan_directory_recursive(&path)?;
-            } else {
-                let metadata = path.metadata()?;
-                if metadata.nlink() > 1 {
-                    let key = (metadata.dev(), metadata.ino());
-                    self.hardlink_groups.entry(key).or_default().push(path);
-                }
+            } else if metadata.nlink() > 1 {
+                let key = (metadata.dev(), metadata.ino());
+                self.hardlink_groups.entry(key).or_default().push(path);
             }
         }
         Ok(())

src/uu/mv/src/mv.rs

@@ -984,6 +984,45 @@ fn rename_symlink_fallback(from: &Path, to: &Path) -> io::Result<()> {
     ))
 }
 
+/// Copy the given symlink to the given destination without dereferencing.
+/// On Windows, dangling symlinks return an error.
+#[cfg(unix)]
+fn copy_symlink(from: &Path, to: &Path) -> io::Result<()> {
+    let from_meta = from.symlink_metadata()?;
+    let path_symlink_points_to = fs::read_link(from)?;
+    unix::fs::symlink(path_symlink_points_to, to).and_then(|_| {
+        try_preserve_ownership(&from_meta, to, false);
+        Ok(())
+    })
+}
+
+#[cfg(windows)]
+fn copy_symlink(from: &Path, to: &Path) -> io::Result<()> {
+    let path_symlink_points_to = fs::read_link(from)?;
+    if path_symlink_points_to.exists() {
+        if path_symlink_points_to.is_dir() {
+            windows::fs::symlink_dir(&path_symlink_points_to, to)?;
+        } else {
+            windows::fs::symlink_file(&path_symlink_points_to, to)?;
+        }
+        Ok(())
+    } else {
+        Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            translate!("mv-error-dangling-symlink"),
+        ))
+    }
+}
+
+#[cfg(not(any(windows, unix)))]
+fn copy_symlink(from: &Path, to: &Path) -> io::Result<()> {
+    let _ = (from, to);
+    Err(io::Error::new(
+        io::ErrorKind::Other,
+        translate!("mv-error-no-symlink-support"),
+    ))
+}
+
 fn rename_dir_fallback(
     from: &Path,
     to: &Path,
@@ -1108,7 +1147,26 @@ fn copy_dir_contents_recursive(
             pb.set_message(from_path.to_string_lossy().to_string());
         }
 
-        if from_path.is_dir() {
+        let entry_type = entry.file_type()?;
+
+        if entry_type.is_symlink() {
+            copy_symlink(&from_path, &to_path)?;
+
+            // Print verbose message for symlink
+            if verbose {
+                let message = translate!(
+                    "mv-verbose-renamed",
+                    "from" => from_path.quote(),
+                    "to" => to_path.quote()
+                );
+                match display_manager {
+                    Some(pb) => pb.suspend(|| {
+                        println!("{message}");
+                    }),
+                    None => println!("{message}"),
+                }
+            }
+        } else if entry_type.is_dir() {
             // Recursively copy subdirectory
             fs::create_dir_all(&to_path)?;