Make two Paths unequal if they differ in trailing slash

Author: dtolnay

library/std/src/path.rs

@@ -1738,7 +1738,7 @@ impl ToOwned for Path {
 impl cmp::PartialEq for PathBuf {
     #[inline]
     fn eq(&self, other: &PathBuf) -> bool {
-        self.components() == other.components()
+        Path::eq(self, other)
     }
 }
 
@@ -1756,15 +1756,15 @@ impl cmp::Eq for PathBuf {}
 impl cmp::PartialOrd for PathBuf {
     #[inline]
     fn partial_cmp(&self, other: &PathBuf) -> Option<cmp::Ordering> {
-        Some(compare_components(self.components(), other.components()))
+        Path::partial_cmp(self, other)
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl cmp::Ord for PathBuf {
     #[inline]
     fn cmp(&self, other: &PathBuf) -> cmp::Ordering {
-        compare_components(self.components(), other.components())
+        Path::cmp(self, other)
     }
 }
 
@@ -2718,6 +2718,14 @@ impl Path {
         let inner = unsafe { Box::from_raw(rw) };
         PathBuf { inner: OsString::from(inner) }
     }
+
+    fn ends_with_separator(&self) -> bool {
+        let components = self.components();
+        match components.path.last() {
+            None => false,
+            Some(byte) => components.is_sep_byte(*byte),
+        }
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -2779,6 +2787,7 @@ impl cmp::PartialEq for Path {
     #[inline]
     fn eq(&self, other: &Path) -> bool {
         self.components() == other.components()
+            && self.ends_with_separator() == other.ends_with_separator()
     }
 }
 
@@ -2798,7 +2807,7 @@ impl cmp::Eq for Path {}
 impl cmp::PartialOrd for Path {
     #[inline]
     fn partial_cmp(&self, other: &Path) -> Option<cmp::Ordering> {
-        Some(compare_components(self.components(), other.components()))
+        Some(Ord::cmp(self, other))
     }
 }
 
@@ -2807,6 +2816,7 @@ impl cmp::Ord for Path {
     #[inline]
     fn cmp(&self, other: &Path) -> cmp::Ordering {
         compare_components(self.components(), other.components())
+            .then_with(|| self.ends_with_separator().cmp(&other.ends_with_separator()))
     }
 }
 

library/std/src/path/tests.rs

@@ -1427,7 +1427,11 @@ pub fn test_compare() {
              let eq = path1 == path2;
              assert!(eq == $eq, "{:?} == {:?}, expected {:?}, got {:?}",
                      $path1, $path2, $eq, eq);
-             assert!($eq == (hash(path1) == hash(path2)),
+
+             // They have the same hash if the paths are equal or differ only in
+             // trailing separator.
+             assert_eq!($eq || $path1.trim_end_matches('/') == $path2.trim_end_matches('/'),
+                     hash(path1) == hash(path2),
                      "{:?} == {:?}, expected {:?}, got {} and {}",
                      $path1, $path2, $eq, hash(path1), hash(path2));
 
@@ -1480,7 +1484,7 @@ pub fn test_compare() {
     );
 
     tc!("foo/", "foo",
-    eq: true,
+    eq: false,
     starts_with: true,
     ends_with: true,
     relative_from: Some("")
@@ -1532,6 +1536,27 @@ pub fn test_compare() {
     }
 }
 
+#[test]
+fn test_trailing_separator() {
+    let file = Path::new("tmp/f");
+    let dir = Path::new("tmp/f/");
+
+    assert_ne!(file, dir);
+    assert!(file < dir);
+    assert_eq!(dir, Path::new("tmp/f//"));
+    assert_eq!(file.components(), dir.components());
+
+    if cfg!(windows) {
+        assert_eq!(dir, Path::new(r"tmp\f\"));
+        assert_eq!(dir, Path::new(r"tmp\f\\"));
+    }
+
+    let file = file.to_owned();
+    let dir = dir.to_owned();
+    assert_ne!(file, dir);
+    assert!(file < dir);
+}
+
 #[test]
 fn test_components_debug() {
     let path = Path::new("/tmp");
@@ -1629,10 +1654,13 @@ fn test_ord() {
     ord!(Less, "1", "2");
     ord!(Less, "/foo/bar", "/foo./bar");
     ord!(Less, "foo/bar", "foo/bar.");
-    ord!(Equal, "foo/./bar", "foo/bar/");
-    ord!(Equal, "foo/bar", "foo/bar/");
+    ord!(Equal, "foo/./bar", "foo/bar");
+    ord!(Less, "foo/./bar", "foo/bar/");
+    ord!(Equal, "foo/./bar/", "foo/bar/");
+    ord!(Less, "foo/bar", "foo/bar/");
     ord!(Equal, "foo/bar", "foo/bar/.");
-    ord!(Equal, "foo/bar", "foo/bar//");
+    ord!(Less, "foo/bar", "foo/bar//");
+    ord!(Equal, "foo/bar/", "foo/bar//");
 }
 
 #[bench]