fix: ensure consistent normalization of UNC paths with trailing separators and \\

Author: hyf0

src/impl_sugar_path.rs

@@ -17,9 +17,9 @@ type StrVec<'a> = SmallVec<[&'a str; 8]>;
 impl SugarPath for Path {
   fn normalize(&self) -> PathBuf {
     let peekable = self.components().peekable();
-    let mut components = to_normalized_components(peekable);
+    let components = to_normalized_components(peekable);
 
-    normalize_inner(&mut components)
+    normalize_inner(&components)
   }
 
   fn absolutize(&self) -> PathBuf {
@@ -51,8 +51,8 @@ impl SugarPath for Path {
         // a UNC path at this points, because UNC paths are always absolute.
         let mut components: ComponentVec = components.collect();
         components.insert(1, Component::RootDir);
-        let mut components = to_normalized_components(components.into_iter().peekable());
-        normalize_inner(&mut components)
+        let components = to_normalized_components(components.into_iter().peekable());
+        normalize_inner(&components)
       } else {
         base.to_mut().push(self);
         base.normalize()
@@ -167,19 +167,77 @@ impl SugarPath for Path {
 }
 
 #[inline]
-fn normalize_inner(components: &mut ComponentVec) -> PathBuf {
+fn normalize_inner(components: &ComponentVec) -> PathBuf {
   if components.is_empty() {
     return PathBuf::from(".");
   }
 
-  if cfg!(target_family = "windows")
-    && components.len() == 1
-    && matches!(components[0], Component::Prefix(_))
-  {
-    components.push(Component::CurDir)
+  let sep = std::path::MAIN_SEPARATOR_STR;
+  let mut result = std::ffi::OsString::with_capacity(
+    components.iter().map(|c| c.as_os_str().len()).sum::<usize>() + components.len(),
+  );
+  let mut need_sep = false;
+
+  for c in components.iter() {
+    match c {
+      #[cfg(target_family = "windows")]
+      Component::Prefix(p) => {
+        if let std::path::Prefix::UNC(server, share) = p.kind() {
+          // Reconstruct UNC prefix from structured data to ensure
+          // correct backslash separators regardless of input format.
+          result.push("\\\\");
+          result.push(server);
+          result.push("\\");
+          result.push(share);
+        } else {
+          result.push(p.as_os_str());
+        }
+        need_sep = false;
+      }
+      #[cfg(not(target_family = "windows"))]
+      Component::Prefix(_) => unreachable!(),
+      Component::RootDir => {
+        result.push(sep);
+        need_sep = false;
+      }
+      Component::Normal(s) => {
+        if need_sep {
+          result.push(sep);
+        }
+        result.push(s);
+        need_sep = true;
+      }
+      Component::ParentDir => {
+        if need_sep {
+          result.push(sep);
+        }
+        result.push("..");
+        need_sep = true;
+      }
+      Component::CurDir => {
+        if need_sep {
+          result.push(sep);
+        }
+        result.push(".");
+        need_sep = true;
+      }
+    }
+  }
+
+  // Prefix-only: append trailing separator or CurDir.
+  // e.g. \\server\share → \\server\share\, C: → C:.
+  #[cfg(target_family = "windows")]
+  if components.len() == 1 {
+    if let Some(Component::Prefix(p)) = components.first() {
+      if matches!(p.kind(), std::path::Prefix::UNC(_, _)) {
+        result.push("\\");
+      } else {
+        result.push(".");
+      }
+    }
   }
 
-  components.iter().collect()
+  PathBuf::from(result)
 }
 
 impl<T: Deref<Target = str>> SugarPath for T {

tests/absolutize_with.rs

@@ -90,8 +90,6 @@ fn windows_absolutize_with_unc_paths() {
     "..\\other".absolutize_with("\\\\server\\share\\folder"),
     "\\\\server\\share\\other"
   );
-  // TODO: should be "\\\\other\\share" — normalize() on a UNC root produces
-  // [Prefix, RootDir] which reconstructs with a trailing `\`.
   assert_eq_str!("\\\\other\\share".absolutize_with("\\\\server\\share"), "\\\\other\\share\\");
 }
 

tests/normalize.rs

@@ -40,9 +40,7 @@ fn windows() {
   assert_eq_str!(p!("/foo/../../../bar").normalize(), "\\bar");
   assert_eq_str!(p!("a//b//../b").normalize(), "a\\b");
   assert_eq_str!(p!("a//b//./c").normalize(), "a\\b\\c");
-  // TODO: should be "\\\\server\\share\\dir\\file.ext" — the UNC prefix preserves
-  // original forward slashes from the input instead of normalizing to backslashes.
-  assert_eq_str!(p!("//server/share/dir/file.ext").normalize(), "//server/share\\dir\\file.ext");
+  assert_eq_str!(p!("//server/share/dir/file.ext").normalize(), "\\\\server\\share\\dir\\file.ext");
   assert_eq_str!(p!("/foo/../../../bar").normalize(), "\\bar");
   assert_eq_str!(p!("/a/b/c/../../../x/y/z").normalize(), "\\x\\y\\z");
   assert_eq_str!(p!("C:").normalize(), "C:.");

tests/relative.rs

@@ -73,9 +73,6 @@ fn windows_unc() {
   let cases = [
     ("\\\\foo\\bar", "\\\\foo\\bar\\baz", "baz"),
     ("\\\\foo\\bar\\baz-quux", "\\\\foo\\bar\\baz", "..\\baz"),
-    // TODO: should be "\\\\foo\\baz" — relative() for cross-root UNC paths
-    // returns the absolute target via normalize(), which produces [Prefix, RootDir]
-    // and reconstructs with a trailing `\`.
     ("\\\\foo\\baz-quux", "\\\\foo\\baz", "\\\\foo\\baz\\"),
     ("\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz-quux", "..\\baz-quux"),
     ("\\\\foo\\bar\\baz", "\\\\foo\\bar", ".."),