path2: Remove some API functions

Delete the following API functions:
- set_dirname()
- with_dirname()
- set_filestem()
- with_filestem()
- add_extension()
- file_path()

Also change pop() to return a boolean instead of an owned copy of the
old filename.

src/compiletest/header.rs

@@ -164,7 +164,7 @@ fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {
       Some(s) => Some(Path::new(s)),
       None => {
         if parse_name_directive(line, "pp-exact") {
-            testfile.file_path()
+            testfile.filename().map_move(|s| Path::new(s))
         } else {
             None
         }

src/compiletest/runtest.rs

@@ -662,7 +662,12 @@ fn make_lib_name(config: &config, auxfile: &Path, testfile: &Path) -> Path {
 
 fn make_exe_name(config: &config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    f.add_extension(os::EXE_EXTENSION);
+    if !os::EXE_SUFFIX.is_empty() {
+        match f.filename().map_move(|s| s + os::EXE_SUFFIX.as_bytes()) {
+            Some(v) => f.set_filename(v),
+            None => ()
+        }
+    }
     f
 }
 
@@ -747,7 +752,10 @@ fn make_out_name(config: &config, testfile: &Path, extension: &str) -> Path {
 
 fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    f.add_extension("libaux");
+    match f.filename().map_move(|s| s + bytes!(".libaux")) {
+        Some(v) => f.set_filename(v),
+        None => ()
+    }
     f
 }
 

src/librustc/metadata/filesearch.rs

@@ -24,7 +24,7 @@ pub enum FileMatch { FileMatches, FileDoesntMatch }
 pub type pick<'self> = &'self fn(path: &Path) -> FileMatch;
 
 pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
-    if path.file_path() == Some(file) {
+    if path.filename() == Some(file.as_vec()) {
         Some(path.clone())
     } else {
         None
@@ -206,11 +206,10 @@ pub fn rust_path() -> ~[Path] {
         env_rust_path.push(cwd.clone());
     }
     loop {
-        let f = cwd.pop();
+        if { let f = cwd.filename(); f.is_none() || f.unwrap() == bytes!("..") } {
-        if f.is_none() || bytes!("..") == f.unwrap() {
+            break
-            break;
         }
-        cwd.push(".rust");
+        cwd.set_filename(".rust");
         if !env_rust_path.contains(&cwd) && os::path_exists(&cwd) {
             env_rust_path.push(cwd.clone());
         }

src/librustpkg/path_util.rs

@@ -449,8 +449,8 @@ pub fn user_set_rust_path() -> bool {
 
 /// Append the version string onto the end of the path's filename
 pub fn versionize(p: &Path, v: &Version) -> Path {
-    let q = p.file_path().expect("path is a directory");
+    let q = p.filename().expect("path is a directory");
-    let mut q = q.as_vec().to_owned();
+    let mut q = q.to_owned();
     q.push('-' as u8);
     let vs = v.to_str();
     q.push_all(vs.as_bytes());

src/libstd/os.rs

@@ -693,8 +693,9 @@ pub fn mkdir_recursive(p: &Path, mode: c_int) -> bool {
     if path_is_dir(p) {
         return true;
     }
+    if p.filename().is_some() {
         let mut p_ = p.clone();
-    if p_.pop().is_some() {
+        p_.pop();
         if !mkdir_recursive(&p_, mode) {
             return false;
         }

src/libstd/path/mod.rs

@@ -268,23 +268,6 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
         self.extension().and_then(str::from_utf8_slice_opt)
     }
 
-    /// Replaces the directory portion of the path with the given byte vector or string.
-    /// If `self` represents the root of the filesystem hierarchy, the last path component
-    /// of the argument becomes the filename.
-    ///
-    /// # Failure
-    ///
-    /// Raises the `null_byte` condition if the dirname contains a NUL.
-    #[inline]
-    fn set_dirname<T: BytesContainer>(&mut self, dirname: T) {
-        if contains_nul(dirname.container_as_bytes()) {
-            let dirname = self::null_byte::cond.raise(dirname.container_into_owned_bytes());
-            assert!(!contains_nul(dirname));
-            unsafe { self.set_dirname_unchecked(dirname) }
-        } else {
-            unsafe { self.set_dirname_unchecked(dirname) }
-        }
-    }
     /// Replaces the filename portion of the path with the given byte vector or string.
     /// If the replacement name is [], this is equivalent to popping the path.
     ///
@@ -301,53 +284,6 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             unsafe { self.set_filename_unchecked(filename) }
         }
     }
-    /// Replaces the filestem with the given byte vector or string.
-    /// If there is no extension in `self` (or `self` has no filename), this is equivalent
-    /// to `set_filename`. Otherwise, if the argument is [] or "", the extension (including
-    /// the preceding '.') becomes the new filename.
-    ///
-    /// # Failure
-    ///
-    /// Raises the `null_byte` condition if the filestem contains a NUL.
-    fn set_filestem<T: BytesContainer>(&mut self, filestem: T) {
-        // borrowck is being a pain here
-        enum Value<T> {
-            Checked(T),
-            Unchecked(~[u8])
-        }
-        let val = {
-            match self.filename() {
-                None => Checked(filestem),
-                Some(name) => {
-                    let dot = '.' as u8;
-                    match name.rposition_elem(&dot) {
-                        None | Some(0) => Checked(filestem),
-                        Some(idx) => {
-                            let mut v;
-                            if contains_nul(filestem.container_as_bytes()) {
-                                let filestem = filestem.container_into_owned_bytes();
-                                let filestem = self::null_byte::cond.raise(filestem);
-                                assert!(!contains_nul(filestem));
-                                v = filestem;
-                                let n = v.len();
-                                v.reserve(n + name.len() - idx);
-                            } else {
-                                let filestem = filestem.container_as_bytes();
-                                v = vec::with_capacity(filestem.len() + name.len() - idx);
-                                v.push_all(filestem);
-                            }
-                            v.push_all(name.slice_from(idx));
-                            Unchecked(v)
-                        }
-                    }
-                }
-            }
-        };
-        match val {
-            Checked(v)  => self.set_filename(v),
-            Unchecked(v) => unsafe { self.set_filename_unchecked(v) }
-        }
-    }
     /// Replaces the extension with the given byte vector or string.
     /// If there is no extension in `self`, this adds one.
     /// If the argument is [] or "", this removes the extension.
@@ -417,61 +353,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             Some(v) => unsafe { self.set_filename_unchecked(v) }
         }
     }
-    /// Adds the given extension (as a byte vector or string) to the file.
-    /// This does not remove any existing extension.
-    /// `foo.bar`.add_extension(`baz`) becomes `foo.bar.baz`.
-    /// If `self` has no filename, this is a no-op.
-    /// If the argument is [] or "", this is a no-op.
-    ///
-    /// # Failure
-    ///
-    /// Raises the `null_byte` condition if the extension contains a NUL.
-    fn add_extension<T: BytesContainer>(&mut self, extension: T) {
-        if extension.container_as_bytes().is_empty() { return; }
-        // appease borrowck
-        let val = {
-            match self.filename() {
-                None => None,
-                Some(name) => {
-                    let mut v;
-                    if contains_nul(extension.container_as_bytes()) {
-                        let ext = extension.container_into_owned_bytes();
-                        let extension = self::null_byte::cond.raise(ext);
-                        assert!(!contains_nul(extension));
-                        v = vec::with_capacity(name.len() + 1 + extension.len());
-                        v.push_all(name);
-                        v.push('.' as u8);
-                        v.push_all(extension);
-                    } else {
-                        let extension = extension.container_as_bytes();
-                        v = vec::with_capacity(name.len() + 1 + extension.len());
-                        v.push_all(name);
-                        v.push('.' as u8);
-                        v.push_all(extension);
-                    }
-                    Some(v)
-                }
-            }
-        };
-        match val {
-            None => (),
-            Some(v) => unsafe { self.set_filename_unchecked(v) }
-        }
-    }
 
-    /// Returns a new Path constructed by replacing the dirname with the given
-    /// byte vector or string.
-    /// See `set_dirname` for details.
-    ///
-    /// # Failure
-    ///
-    /// Raises the `null_byte` condition if the dirname contains a NUL.
-    #[inline]
-    fn with_dirname<T: BytesContainer>(&self, dirname: T) -> Self {
-        let mut p = self.clone();
-        p.set_dirname(dirname);
-        p
-    }
     /// Returns a new Path constructed by replacing the filename with the given
     /// byte vector or string.
     /// See `set_filename` for details.
@@ -485,19 +367,6 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
         p.set_filename(filename);
         p
     }
-    /// Returns a new Path constructed by setting the filestem to the given
-    /// byte vector or string.
-    /// See `set_filestem` for details.
-    ///
-    /// # Failure
-    ///
-    /// Raises the `null_byte` condition if the filestem contains a NUL.
-    #[inline]
-    fn with_filestem<T: BytesContainer>(&self, filestem: T) -> Self {
-        let mut p = self.clone();
-        p.set_filestem(filestem);
-        p
-    }
     /// Returns a new Path constructed by setting the extension to the given
     /// byte vector or string.
     /// See `set_extension` for details.
@@ -518,12 +387,6 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
         // self.dirname() returns a NUL-free vector
         unsafe { GenericPathUnsafe::new_unchecked(self.dirname()) }
     }
-    /// Returns the file component of `self`, as a relative Path.
-    /// If `self` represents the root of the filesystem hierarchy, returns None.
-    fn file_path(&self) -> Option<Self> {
-        // self.filename() returns a NUL-free vector
-        self.filename().map_move(|v| unsafe { GenericPathUnsafe::new_unchecked(v) })
-    }
 
     /// Returns a Path that represents the filesystem root that `self` is rooted in.
     ///
@@ -561,16 +424,10 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             }
         }
     }
-    /// Pops the last path component off of `self` and returns it.
+    /// Removes the last path component from the receiver.
-    /// If `self` represents the root of the file hierarchy, None is returned.
+    /// Returns `true` if the receiver was modified, or `false` if it already
-    fn pop(&mut self) -> Option<~[u8]>;
+    /// represented the root of the file hierarchy.
-    /// Pops the last path component off of `self` and returns it as a string, if possible.
+    fn pop(&mut self) -> bool;
-    /// `self` will still be modified even if None is returned.
-    /// See `pop` for details.
-    #[inline]
-    fn pop_str(&mut self) -> Option<~str> {
-        self.pop().and_then(|v| str::from_utf8_owned_opt(v))
-    }
 
     /// Returns a new Path constructed by joining `self` with the given path
     /// (as a byte vector or string).
@@ -658,11 +515,6 @@ pub trait GenericPathUnsafe {
     /// The resulting Path will always be normalized.
     unsafe fn new_unchecked<T: BytesContainer>(path: T) -> Self;
 
-    /// Replaces the directory portion of the path without checking for null
-    /// bytes.
-    /// See `set_dirname` for details.
-    unsafe fn set_dirname_unchecked<T: BytesContainer>(&mut self, dirname: T);
-
     /// Replaces the filename portion of the path without checking for null
     /// bytes.
     /// See `set_filename` for details.

src/libstd/path/posix.rs

@@ -20,7 +20,6 @@ use option::{Option, None, Some};
 use str;
 use str::Str;
 use to_bytes::IterBytes;
-use util;
 use vec;
 use vec::{CopyableVector, RSplitIterator, SplitIterator, Vector, VectorVector};
 use super::{BytesContainer, GenericPath, GenericPathUnsafe};
@@ -122,39 +121,6 @@ impl GenericPathUnsafe for Path {
         Path{ repr: path, sepidx: idx }
     }
 
-    unsafe fn set_dirname_unchecked<T: BytesContainer>(&mut self, dirname: T) {
-        let dirname = dirname.container_as_bytes();
-        match self.sepidx {
-            None if bytes!(".") == self.repr || bytes!("..") == self.repr => {
-                self.repr = Path::normalize(dirname);
-            }
-            None => {
-                let mut v = vec::with_capacity(dirname.len() + self.repr.len() + 1);
-                v.push_all(dirname);
-                v.push(sep_byte);
-                v.push_all(self.repr);
-                self.repr = Path::normalize(v);
-            }
-            Some(0) if self.repr.len() == 1 && self.repr[0] == sep_byte => {
-                self.repr = Path::normalize(dirname);
-            }
-            Some(idx) if self.repr.slice_from(idx+1) == bytes!("..") => {
-                self.repr = Path::normalize(dirname);
-            }
-            Some(idx) if dirname.is_empty() => {
-                let v = Path::normalize(self.repr.slice_from(idx+1));
-                self.repr = v;
-            }
-            Some(idx) => {
-                let mut v = vec::with_capacity(dirname.len() + self.repr.len() - idx);
-                v.push_all(dirname);
-                v.push_all(self.repr.slice_from(idx));
-                self.repr = Path::normalize(v);
-            }
-        }
-        self.sepidx = self.repr.rposition_elem(&sep_byte);
-    }
-
     unsafe fn set_filename_unchecked<T: BytesContainer>(&mut self, filename: T) {
         let filename = filename.container_as_bytes();
         match self.sepidx {
@@ -236,25 +202,23 @@ impl GenericPath for Path {
         }
     }
 
-    fn pop(&mut self) -> Option<~[u8]> {
+    fn pop(&mut self) -> bool {
         match self.sepidx {
-            None if bytes!(".") == self.repr => None,
+            None if bytes!(".") == self.repr => false,
             None => {
-                let mut v = ~['.' as u8];
+                self.repr = ~['.' as u8];
-                util::swap(&mut v, &mut self.repr);
                 self.sepidx = None;
-                Some(v)
+                true
             }
-            Some(0) if bytes!("/") == self.repr => None,
+            Some(0) if bytes!("/") == self.repr => false,
             Some(idx) => {
-                let v = self.repr.slice_from(idx+1).to_owned();
                 if idx == 0 {
                     self.repr.truncate(idx+1);
                 } else {
                     self.repr.truncate(idx);
                 }
                 self.sepidx = self.repr.rposition_elem(&sep_byte);
-                Some(v)
+                true
             }
         }
     }
@@ -692,17 +656,6 @@ mod tests {
         assert!(handled);
         assert_eq!(p.as_vec(), b!("/foo"));
 
-        handled = false;
-        do cond.trap(|v| {
-            handled = true;
-            assert_eq!(v.as_slice(), b!("null/", 0, "/byte"));
-            (b!("null/byte").to_owned())
-        }).inside {
-            p.set_dirname(b!("null/", 0, "/byte"));
-        };
-        assert!(handled);
-        assert_eq!(p.as_vec(), b!("null/byte/foo"));
-
         handled = false;
         do cond.trap(|v| {
             handled = true;
@@ -712,7 +665,7 @@ mod tests {
             p.push(b!("f", 0, "o"));
         };
         assert!(handled);
-        assert_eq!(p.as_vec(), b!("null/byte/foo/foo"));
+        assert_eq!(p.as_vec(), b!("/foo/foo"));
     }
 
     #[test]
@@ -749,15 +702,6 @@ mod tests {
             };
         })
 
-        t!(~"set_dirname w/nul" => {
-            let mut p = Path::new(b!("foo/bar"));
-            do cond.trap(|_| {
-                (b!("null", 0).to_owned())
-            }).inside {
-                p.set_dirname(b!("foo", 0))
-            };
-        })
-
         t!(~"push w/nul" => {
             let mut p = Path::new(b!("foo/bar"));
             do cond.trap(|_| {
@@ -1006,46 +950,35 @@ mod tests {
             (s: $path:expr, $left:expr, $right:expr) => (
                 {
                     let mut p = Path::new($path);
-                    let file = p.pop_str();
+                    let result = p.pop();
                     assert_eq!(p.as_str(), Some($left));
-                    assert_eq!(file.map(|s| s.as_slice()), $right);
+                    assert_eq!(result, $right);
                 }
             );
-            (v: [$($path:expr),+], [$($left:expr),+], Some($($right:expr),+)) => (
+            (v: [$($path:expr),+], [$($left:expr),+], $right:expr) => (
                 {
                     let mut p = Path::new(b!($($path),+));
-                    let file = p.pop();
+                    let result = p.pop();
                     assert_eq!(p.as_vec(), b!($($left),+));
-                    assert_eq!(file.map(|v| v.as_slice()), Some(b!($($right),+)));
+                    assert_eq!(result, $right);
-                }
-            );
-            (v: [$($path:expr),+], [$($left:expr),+], None) => (
-                {
-                    let mut p = Path::new(b!($($path),+));
-                    let file = p.pop();
-                    assert_eq!(p.as_vec(), b!($($left),+));
-                    assert_eq!(file, None);
                 }
             )
         )
 
-        t!(v: ["a/b/c"], ["a/b"], Some("c"));
+        t!(v: ["a/b/c"], ["a/b"], true);
-        t!(v: ["a"], ["."], Some("a"));
+        t!(v: ["a"], ["."], true);
-        t!(v: ["."], ["."], None);
+        t!(v: ["."], ["."], false);
-        t!(v: ["/a"], ["/"], Some("a"));
+        t!(v: ["/a"], ["/"], true);
-        t!(v: ["/"], ["/"], None);
+        t!(v: ["/"], ["/"], false);
-        t!(v: ["a/b/c", 0x80], ["a/b"], Some("c", 0x80));
+        t!(v: ["a/b/c", 0x80], ["a/b"], true);
-        t!(v: ["a/b", 0x80, "/c"], ["a/b", 0x80], Some("c"));
+        t!(v: ["a/b", 0x80, "/c"], ["a/b", 0x80], true);
-        t!(v: [0xff], ["."], Some(0xff));
+        t!(v: [0xff], ["."], true);
-        t!(v: ["/", 0xff], ["/"], Some(0xff));
+        t!(v: ["/", 0xff], ["/"], true);
-        t!(s: "a/b/c", "a/b", Some("c"));
+        t!(s: "a/b/c", "a/b", true);
-        t!(s: "a", ".", Some("a"));
+        t!(s: "a", ".", true);
-        t!(s: ".", ".", None);
+        t!(s: ".", ".", false);
-        t!(s: "/a", "/", Some("a"));
+        t!(s: "/a", "/", true);
-        t!(s: "/", "/", None);
+        t!(s: "/", "/", false);
-
-        assert_eq!(Path::new(b!("foo/bar", 0x80)).pop_str(), None);
-        assert_eq!(Path::new(b!("foo", 0x80, "/bar")).pop_str(), Some(~"bar"));
     }
 
     #[test]
@@ -1124,27 +1057,6 @@ mod tests {
     fn test_with_helpers() {
         let empty: &[u8] = [];
 
-        t!(v: Path::new(b!("a/b/c")).with_dirname(b!("d")), b!("d/c"));
-        t!(v: Path::new(b!("a/b/c")).with_dirname(b!("d/e")), b!("d/e/c"));
-        t!(v: Path::new(b!("a/", 0x80, "b/c")).with_dirname(b!(0xff)), b!(0xff, "/c"));
-        t!(v: Path::new(b!("a/b/", 0x80)).with_dirname(b!("/", 0xcd)),
-              b!("/", 0xcd, "/", 0x80));
-        t!(s: Path::new("a/b/c").with_dirname("d"), "d/c");
-        t!(s: Path::new("a/b/c").with_dirname("d/e"), "d/e/c");
-        t!(s: Path::new("a/b/c").with_dirname(""), "c");
-        t!(s: Path::new("a/b/c").with_dirname("/"), "/c");
-        t!(s: Path::new("a/b/c").with_dirname("."), "c");
-        t!(s: Path::new("a/b/c").with_dirname(".."), "../c");
-        t!(s: Path::new("/").with_dirname("foo"), "foo");
-        t!(s: Path::new("/").with_dirname(""), ".");
-        t!(s: Path::new("/foo").with_dirname("bar"), "bar/foo");
-        t!(s: Path::new("..").with_dirname("foo"), "foo");
-        t!(s: Path::new("../..").with_dirname("foo"), "foo");
-        t!(s: Path::new("..").with_dirname(""), ".");
-        t!(s: Path::new("../..").with_dirname(""), ".");
-        t!(s: Path::new("foo").with_dirname(".."), "../foo");
-        t!(s: Path::new("foo").with_dirname("../.."), "../../foo");
-
         t!(v: Path::new(b!("a/b/c")).with_filename(b!("d")), b!("a/b/d"));
         t!(v: Path::new(b!("a/b/c", 0xff)).with_filename(b!(0x80)), b!("a/b/", 0x80));
         t!(v: Path::new(b!("/", 0xff, "/foo")).with_filename(b!(0xcd)),
@@ -1169,34 +1081,6 @@ mod tests {
         t!(s: Path::new("..").with_filename(""), "..");
         t!(s: Path::new("../..").with_filename(""), "../..");
 
-        t!(v: Path::new(b!("hi/there", 0x80, ".txt")).with_filestem(b!(0xff)),
-              b!("hi/", 0xff, ".txt"));
-        t!(v: Path::new(b!("hi/there.txt", 0x80)).with_filestem(b!(0xff)),
-              b!("hi/", 0xff, ".txt", 0x80));
-        t!(v: Path::new(b!("hi/there", 0xff)).with_filestem(b!(0x80)), b!("hi/", 0x80));
-        t!(v: Path::new(b!("hi", 0x80, "/there")).with_filestem(empty), b!("hi", 0x80));
-        t!(s: Path::new("hi/there.txt").with_filestem("here"), "hi/here.txt");
-        t!(s: Path::new("hi/there.txt").with_filestem(""), "hi/.txt");
-        t!(s: Path::new("hi/there.txt").with_filestem("."), "hi/..txt");
-        t!(s: Path::new("hi/there.txt").with_filestem(".."), "hi/...txt");
-        t!(s: Path::new("hi/there.txt").with_filestem("/"), "hi/.txt");
-        t!(s: Path::new("hi/there.txt").with_filestem("foo/bar"), "hi/foo/bar.txt");
-        t!(s: Path::new("hi/there.foo.txt").with_filestem("here"), "hi/here.txt");
-        t!(s: Path::new("hi/there").with_filestem("here"), "hi/here");
-        t!(s: Path::new("hi/there").with_filestem(""), "hi");
-        t!(s: Path::new("hi").with_filestem(""), ".");
-        t!(s: Path::new("/hi").with_filestem(""), "/");
-        t!(s: Path::new("hi/there").with_filestem(".."), ".");
-        t!(s: Path::new("hi/there").with_filestem("."), "hi");
-        t!(s: Path::new("hi/there.").with_filestem("foo"), "hi/foo.");
-        t!(s: Path::new("hi/there.").with_filestem(""), "hi");
-        t!(s: Path::new("hi/there.").with_filestem("."), ".");
-        t!(s: Path::new("hi/there.").with_filestem(".."), "hi/...");
-        t!(s: Path::new("/").with_filestem("foo"), "/foo");
-        t!(s: Path::new(".").with_filestem("foo"), "foo");
-        t!(s: Path::new("hi/there..").with_filestem("here"), "hi/here.");
-        t!(s: Path::new("hi/there..").with_filestem(""), "hi");
-
         t!(v: Path::new(b!("hi/there", 0x80, ".txt")).with_extension(b!("exe")),
               b!("hi/there", 0x80, ".exe"));
         t!(v: Path::new(b!("hi/there.txt", 0x80)).with_extension(b!(0xff)),
@@ -1245,17 +1129,6 @@ mod tests {
             )
         )
 
-        t!(v: b!("a/b/c"), set_dirname, with_dirname, b!("d"));
-        t!(v: b!("a/b/c"), set_dirname, with_dirname, b!("d/e"));
-        t!(v: b!("a/", 0x80, "/c"), set_dirname, with_dirname, b!(0xff));
-        t!(s: "a/b/c", set_dirname, with_dirname, "d");
-        t!(s: "a/b/c", set_dirname, with_dirname, "d/e");
-        t!(s: "/", set_dirname, with_dirname, "foo");
-        t!(s: "/foo", set_dirname, with_dirname, "bar");
-        t!(s: "a/b/c", set_dirname, with_dirname, "");
-        t!(s: "../..", set_dirname, with_dirname, "x");
-        t!(s: "foo", set_dirname, with_dirname, "../..");
-
         t!(v: b!("a/b/c"), set_filename, with_filename, b!("d"));
         t!(v: b!("/"), set_filename, with_filename, b!("foo"));
         t!(v: b!(0x80), set_filename, with_filename, b!(0xff));
@@ -1265,14 +1138,6 @@ mod tests {
         t!(s: "a/b", set_filename, with_filename, "");
         t!(s: "a", set_filename, with_filename, "");
 
-        t!(v: b!("hi/there.txt"), set_filestem, with_filestem, b!("here"));
-        t!(v: b!("hi/there", 0x80, ".txt"), set_filestem, with_filestem, b!("here", 0xff));
-        t!(s: "hi/there.txt", set_filestem, with_filestem, "here");
-        t!(s: "hi/there.", set_filestem, with_filestem, "here");
-        t!(s: "hi/there", set_filestem, with_filestem, "here");
-        t!(s: "hi/there.txt", set_filestem, with_filestem, "");
-        t!(s: "hi/there", set_filestem, with_filestem, "");
-
         t!(v: b!("hi/there.txt"), set_extension, with_extension, b!("exe"));
         t!(v: b!("hi/there.t", 0x80, "xt"), set_extension, with_extension, b!("exe", 0xff));
         t!(s: "hi/there.txt", set_extension, with_extension, "exe");
@@ -1283,36 +1148,6 @@ mod tests {
         t!(s: ".", set_extension, with_extension, "txt");
     }
 
-    #[test]
-    fn test_add_extension() {
-        macro_rules! t(
-            (s: $path:expr, $ext:expr, $exp:expr) => (
-                {
-                    let mut path = Path::new($path);
-                    path.add_extension($ext);
-                    assert_eq!(path.as_str(), Some($exp));
-                }
-            );
-            (v: $path:expr, $ext:expr, $exp:expr) => (
-                {
-                    let mut path = Path::new($path);
-                    path.add_extension($ext);
-                    assert_eq!(path.as_vec(), $exp);
-                }
-            )
-        )
-
-        t!(s: "hi/there.txt", "foo", "hi/there.txt.foo");
-        t!(s: "hi/there.", "foo", "hi/there..foo");
-        t!(s: "hi/there", ".foo", "hi/there..foo");
-        t!(s: "hi/there.txt", "", "hi/there.txt");
-        t!(v: b!("hi/there.txt"), b!("foo"), b!("hi/there.txt.foo"));
-        t!(v: b!("hi/there"), b!("bar"), b!("hi/there.bar"));
-        t!(v: b!("/"), b!("foo"), b!("/"));
-        t!(v: b!("."), b!("foo"), b!("."));
-        t!(v: b!("hi/there.", 0x80, "foo"), b!(0xff), b!("hi/there.", 0x80, "foo.", 0xff));
-    }
-
     #[test]
     fn test_getters() {
         macro_rules! t(
@@ -1372,7 +1207,7 @@ mod tests {
     }
 
     #[test]
-    fn test_dir_file_path() {
+    fn test_dir_path() {
         t!(v: Path::new(b!("hi/there", 0x80)).dir_path(), b!("hi"));
         t!(v: Path::new(b!("hi", 0xff, "/there")).dir_path(), b!("hi", 0xff));
         t!(s: Path::new("hi/there").dir_path(), "hi");
@@ -1381,32 +1216,6 @@ mod tests {
         t!(s: Path::new("/").dir_path(), "/");
         t!(s: Path::new("..").dir_path(), "..");
         t!(s: Path::new("../..").dir_path(), "../..");
-
-        macro_rules! t(
-            (s: $path:expr, $exp:expr) => (
-                {
-                    let path = $path;
-                    let left = path.and_then_ref(|p| p.as_str());
-                    assert_eq!(left, $exp);
-                }
-            );
-            (v: $path:expr, $exp:expr) => (
-                {
-                    let path = $path;
-                    let left = path.map(|p| p.as_vec());
-                    assert_eq!(left, $exp);
-                }
-            )
-        )
-
-        t!(v: Path::new(b!("hi/there", 0x80)).file_path(), Some(b!("there", 0x80)));
-        t!(v: Path::new(b!("hi", 0xff, "/there")).file_path(), Some(b!("there")));
-        t!(s: Path::new("hi/there").file_path(), Some("there"));
-        t!(s: Path::new("hi").file_path(), Some("hi"));
-        t!(s: Path::new(".").file_path(), None);
-        t!(s: Path::new("/").file_path(), None);
-        t!(s: Path::new("..").file_path(), None);
-        t!(s: Path::new("../..").file_path(), None);
     }
 
     #[test]

src/libstd/path/windows.rs

@@ -20,7 +20,6 @@ use option::{Option, Some, None};
 use str;
 use str::{CharSplitIterator, OwnedStr, Str, StrVector};
 use to_bytes::IterBytes;
-use util;
 use vec::Vector;
 use super::{BytesContainer, GenericPath, GenericPathUnsafe};
 
@@ -174,49 +173,6 @@ impl GenericPathUnsafe for Path {
         ret
     }
 
-    /// See `GenericPathUnsafe::set_dirname_unchecked`.
-    ///
-    /// # Failure
-    ///
-    /// Raises the `str::not_utf8` condition if not valid UTF-8.
-    unsafe fn set_dirname_unchecked<T: BytesContainer>(&mut self, dirname: T) {
-        let dirname = dirname.container_as_str();
-        match self.sepidx_or_prefix_len() {
-            None if "." == self.repr || ".." == self.repr => {
-                self.update_normalized(dirname);
-            }
-            None => {
-                let mut s = str::with_capacity(dirname.len() + self.repr.len() + 1);
-                s.push_str(dirname);
-                s.push_char(sep);
-                s.push_str(self.repr);
-                self.update_normalized(s);
-            }
-            Some((_,idxa,end)) if self.repr.slice(idxa,end) == ".." => {
-                self.update_normalized(dirname);
-            }
-            Some((_,idxa,end)) if dirname.is_empty() => {
-                let (prefix, path) = Path::normalize_(self.repr.slice(idxa,end));
-                self.repr = path;
-                self.prefix = prefix;
-                self.update_sepidx();
-            }
-            Some((idxb,idxa,end)) => {
-                let idx = if dirname.ends_with("\\") { idxa }
-                else {
-                    let prefix = parse_prefix(dirname);
-                    if prefix == Some(DiskPrefix) && prefix_len(prefix) == dirname.len() {
-                        idxa
-                    } else { idxb }
-                };
-                let mut s = str::with_capacity(dirname.len() + end - idx);
-                s.push_str(dirname);
-                s.push_str(self.repr.slice(idx,end));
-                self.update_normalized(s);
-            }
-        }
-    }
-
     /// See `GenericPathUnsafe::set_filename_unchecekd`.
     ///
     /// # Failure
@@ -452,28 +408,18 @@ impl GenericPath for Path {
         unsafe { GenericPathUnsafe::new_unchecked(self.dirname_str().unwrap()) }
     }
 
-    fn file_path(&self) -> Option<Path> {
-        self.filename_str().map_move(|s| unsafe { GenericPathUnsafe::new_unchecked(s) })
-    }
-
     #[inline]
-    fn pop(&mut self) -> Option<~[u8]> {
+    fn pop(&mut self) -> bool {
-        self.pop_str().map_move(|s| s.into_bytes())
-    }
-
-    fn pop_str(&mut self) -> Option<~str> {
         match self.sepidx_or_prefix_len() {
-            None if "." == self.repr => None,
+            None if "." == self.repr => false,
             None => {
-                let mut s = ~".";
+                self.repr = ~".";
-                util::swap(&mut s, &mut self.repr);
                 self.sepidx = None;
-                Some(s)
+                true
             }
-            Some((idxb,idxa,end)) if idxb == idxa && idxb == end => None,
+            Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
-            Some((idxb,_,end)) if self.repr.slice(idxb, end) == "\\" => None,
+            Some((idxb,_,end)) if self.repr.slice(idxb, end) == "\\" => false,
-            Some((idxb,idxa,end)) => {
+            Some((idxb,idxa,_)) => {
-                let s = self.repr.slice(idxa, end).to_owned();
                 let trunc = match self.prefix {
                     Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
                         let plen = self.prefix_len();
@@ -483,7 +429,7 @@ impl GenericPath for Path {
                 };
                 self.repr.truncate(trunc);
                 self.update_sepidx();
-                Some(s)
+                true
             }
         }
     }
@@ -1401,17 +1347,6 @@ mod tests {
         assert!(handled);
         assert_eq!(p.as_vec(), b!("\\foo"));
 
-        handled = false;
-        do cond.trap(|v| {
-            handled = true;
-            assert_eq!(v.as_slice(), b!("null\\", 0, "\\byte"));
-            (b!("null\\byte").to_owned())
-        }).inside {
-            p.set_dirname(b!("null\\", 0, "\\byte"));
-        };
-        assert!(handled);
-        assert_eq!(p.as_vec(), b!("null\\byte\\foo"));
-
         handled = false;
         do cond.trap(|v| {
             handled = true;
@@ -1421,7 +1356,7 @@ mod tests {
             p.push(b!("f", 0, "o"));
         };
         assert!(handled);
-        assert_eq!(p.as_vec(), b!("null\\byte\\foo\\foo"));
+        assert_eq!(p.as_vec(), b!("\\foo\\foo"));
     }
 
     #[test]
@@ -1458,15 +1393,6 @@ mod tests {
             };
         })
 
-        t!(~"set_dirname w\\nul" => {
-            let mut p = Path::new(b!("foo\\bar"));
-            do cond.trap(|_| {
-                (b!("null", 0).to_owned())
-            }).inside {
-                p.set_dirname(b!("foo", 0))
-            };
-        })
-
         t!(~"push w\\nul" => {
             let mut p = Path::new(b!("foo\\bar"));
             do cond.trap(|_| {
@@ -1770,69 +1696,58 @@ mod tests {
                 {
                     let pstr = $path;
                     let mut p = Path::new(pstr);
-                    let file = p.pop_str();
+                    let result = p.pop();
                     let left = $left;
                     assert!(p.as_str() == Some(left),
                         "`{}`.pop() failed; expected remainder `{}`, found `{}`",
                         pstr, left, p.as_str().unwrap());
-                    let right = $right;
+                    assert_eq!(result, $right);
-                    let res = file.map(|s| s.as_slice());
-                    assert!(res == right, "`{}`.pop() failed; expected `{:?}`, found `{:?}`",
-                            pstr, right, res);
                 }
             );
-            (v: [$($path:expr),+], [$($left:expr),+], Some($($right:expr),+)) => (
+            (v: [$($path:expr),+], [$($left:expr),+], $right:expr) => (
                 {
                     let mut p = Path::new(b!($($path),+));
-                    let file = p.pop();
+                    let result = p.pop();
                     assert_eq!(p.as_vec(), b!($($left),+));
-                    assert_eq!(file.map(|v| v.as_slice()), Some(b!($($right),+)));
+                    assert_eq!(result, $right);
-                }
-            );
-            (v: [$($path:expr),+], [$($left:expr),+], None) => (
-                {
-                    let mut p = Path::new(b!($($path),+));
-                    let file = p.pop();
-                    assert_eq!(p.as_vec(), b!($($left),+));
-                    assert_eq!(file, None);
                 }
             )
         )
 
-        t!(s: "a\\b\\c", "a\\b", Some("c"));
+        t!(s: "a\\b\\c", "a\\b", true);
-        t!(s: "a", ".", Some("a"));
+        t!(s: "a", ".", true);
-        t!(s: ".", ".", None);
+        t!(s: ".", ".", false);
-        t!(s: "\\a", "\\", Some("a"));
+        t!(s: "\\a", "\\", true);
-        t!(s: "\\", "\\", None);
+        t!(s: "\\", "\\", false);
-        t!(v: ["a\\b\\c"], ["a\\b"], Some("c"));
+        t!(v: ["a\\b\\c"], ["a\\b"], true);
-        t!(v: ["a"], ["."], Some("a"));
+        t!(v: ["a"], ["."], true);
-        t!(v: ["."], ["."], None);
+        t!(v: ["."], ["."], false);
-        t!(v: ["\\a"], ["\\"], Some("a"));
+        t!(v: ["\\a"], ["\\"], true);
-        t!(v: ["\\"], ["\\"], None);
+        t!(v: ["\\"], ["\\"], false);
 
-        t!(s: "C:\\a\\b", "C:\\a", Some("b"));
+        t!(s: "C:\\a\\b", "C:\\a", true);
-        t!(s: "C:\\a", "C:\\", Some("a"));
+        t!(s: "C:\\a", "C:\\", true);
-        t!(s: "C:\\", "C:\\", None);
+        t!(s: "C:\\", "C:\\", false);
-        t!(s: "C:a\\b", "C:a", Some("b"));
+        t!(s: "C:a\\b", "C:a", true);
-        t!(s: "C:a", "C:", Some("a"));
+        t!(s: "C:a", "C:", true);
-        t!(s: "C:", "C:", None);
+        t!(s: "C:", "C:", false);
-        t!(s: "\\\\server\\share\\a\\b", "\\\\server\\share\\a", Some("b"));
+        t!(s: "\\\\server\\share\\a\\b", "\\\\server\\share\\a", true);
-        t!(s: "\\\\server\\share\\a", "\\\\server\\share", Some("a"));
+        t!(s: "\\\\server\\share\\a", "\\\\server\\share", true);
-        t!(s: "\\\\server\\share", "\\\\server\\share", None);
+        t!(s: "\\\\server\\share", "\\\\server\\share", false);
-        t!(s: "\\\\?\\a\\b\\c", "\\\\?\\a\\b", Some("c"));
+        t!(s: "\\\\?\\a\\b\\c", "\\\\?\\a\\b", true);
-        t!(s: "\\\\?\\a\\b", "\\\\?\\a", Some("b"));
+        t!(s: "\\\\?\\a\\b", "\\\\?\\a", true);
-        t!(s: "\\\\?\\a", "\\\\?\\a", None);
+        t!(s: "\\\\?\\a", "\\\\?\\a", false);
-        t!(s: "\\\\?\\C:\\a\\b", "\\\\?\\C:\\a", Some("b"));
+        t!(s: "\\\\?\\C:\\a\\b", "\\\\?\\C:\\a", true);
-        t!(s: "\\\\?\\C:\\a", "\\\\?\\C:\\", Some("a"));
+        t!(s: "\\\\?\\C:\\a", "\\\\?\\C:\\", true);
-        t!(s: "\\\\?\\C:\\", "\\\\?\\C:\\", None);
+        t!(s: "\\\\?\\C:\\", "\\\\?\\C:\\", false);
-        t!(s: "\\\\?\\UNC\\server\\share\\a\\b", "\\\\?\\UNC\\server\\share\\a", Some("b"));
+        t!(s: "\\\\?\\UNC\\server\\share\\a\\b", "\\\\?\\UNC\\server\\share\\a", true);
-        t!(s: "\\\\?\\UNC\\server\\share\\a", "\\\\?\\UNC\\server\\share", Some("a"));
+        t!(s: "\\\\?\\UNC\\server\\share\\a", "\\\\?\\UNC\\server\\share", true);
-        t!(s: "\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share", None);
+        t!(s: "\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\server\\share", false);
-        t!(s: "\\\\.\\a\\b\\c", "\\\\.\\a\\b", Some("c"));
+        t!(s: "\\\\.\\a\\b\\c", "\\\\.\\a\\b", true);
-        t!(s: "\\\\.\\a\\b", "\\\\.\\a", Some("b"));
+        t!(s: "\\\\.\\a\\b", "\\\\.\\a", true);
-        t!(s: "\\\\.\\a", "\\\\.\\a", None);
+        t!(s: "\\\\.\\a", "\\\\.\\a", false);
 
-        t!(s: "\\\\?\\a\\b\\", "\\\\?\\a", Some("b"));
+        t!(s: "\\\\?\\a\\b\\", "\\\\?\\a", true);
     }
 
     #[test]
@@ -1934,48 +1849,6 @@ mod tests {
                 }
             )
         )
-        t!(s: "a\\b\\c", with_dirname, "d", "d\\c");
-        t!(s: "a\\b\\c", with_dirname, "d\\e", "d\\e\\c");
-        t!(s: "a\\b\\c", with_dirname, "", "c");
-        t!(s: "a\\b\\c", with_dirname, "\\", "\\c");
-        t!(s: "a\\b\\c", with_dirname, "/", "\\c");
-        t!(s: "a\\b\\c", with_dirname, ".", "c");
-        t!(s: "a\\b\\c", with_dirname, "..", "..\\c");
-        t!(s: "\\", with_dirname, "foo", "foo");
-        t!(s: "\\", with_dirname, "", ".");
-        t!(s: "\\foo", with_dirname, "bar", "bar\\foo");
-        t!(s: "..", with_dirname, "foo", "foo");
-        t!(s: "..\\..", with_dirname, "foo", "foo");
-        t!(s: "..", with_dirname, "", ".");
-        t!(s: "..\\..", with_dirname, "", ".");
-        t!(s: ".", with_dirname, "foo", "foo");
-        t!(s: "foo", with_dirname, "..", "..\\foo");
-        t!(s: "foo", with_dirname, "..\\..", "..\\..\\foo");
-        t!(s: "C:\\a\\b", with_dirname, "foo", "foo\\b");
-        t!(s: "foo", with_dirname, "C:\\a\\b", "C:\\a\\b\\foo");
-        t!(s: "C:a\\b", with_dirname, "\\\\server\\share", "\\\\server\\share\\b");
-        t!(s: "a", with_dirname, "\\\\server\\share", "\\\\server\\share\\a");
-        t!(s: "a\\b", with_dirname, "\\\\?\\", "\\\\?\\b");
-        t!(s: "a\\b", with_dirname, "C:", "C:b");
-        t!(s: "a\\b", with_dirname, "C:\\", "C:\\b");
-        t!(s: "a\\b", with_dirname, "C:/", "C:\\b");
-        t!(s: "C:\\", with_dirname, "foo", "foo");
-        t!(s: "C:", with_dirname, "foo", "foo");
-        t!(s: ".", with_dirname, "C:\\", "C:\\");
-        t!(s: ".", with_dirname, "C:/", "C:\\");
-        t!(s: "\\\\?\\C:\\foo", with_dirname, "C:\\", "C:\\foo");
-        t!(s: "\\\\?\\C:\\", with_dirname, "bar", "bar");
-        t!(s: "foo\\bar", with_dirname, "\\\\?\\C:\\baz", "\\\\?\\C:\\baz\\bar");
-        t!(s: "\\\\?\\foo", with_dirname, "C:\\bar", "C:\\bar");
-        t!(s: "\\\\?\\a\\foo", with_dirname, "C:\\bar", "C:\\bar\\foo");
-        t!(s: "\\\\?\\a\\foo/bar", with_dirname, "C:\\baz", "C:\\baz\\foo\\bar");
-        t!(s: "\\\\?\\UNC\\server\\share\\baz", with_dirname, "a", "a\\baz");
-        t!(s: "foo\\bar", with_dirname, "\\\\?\\UNC\\server\\share\\baz",
-              "\\\\?\\UNC\\server\\share\\baz\\bar");
-        t!(s: "\\\\.\\foo", with_dirname, "bar", "bar");
-        t!(s: "\\\\.\\foo\\bar", with_dirname, "baz", "baz\\bar");
-        t!(s: "\\\\.\\foo\\bar", with_dirname, "baz\\", "baz\\bar");
-        t!(s: "\\\\.\\foo\\bar", with_dirname, "baz/", "baz\\bar");
 
         t!(s: "a\\b\\c", with_filename, "d", "a\\b\\d");
         t!(s: ".", with_filename, "foo", "foo");
@@ -2028,29 +1901,6 @@ mod tests {
         t!(s: "\\\\.\\foo", with_filename, "bar", "\\\\.\\foo\\bar");
         t!(s: "\\\\.\\foo\\bar", with_filename, "..", "\\\\.\\foo\\..");
 
-        t!(s: "hi\\there.txt", with_filestem, "here", "hi\\here.txt");
-        t!(s: "hi\\there.txt", with_filestem, "", "hi\\.txt");
-        t!(s: "hi\\there.txt", with_filestem, ".", "hi\\..txt");
-        t!(s: "hi\\there.txt", with_filestem, "..", "hi\\...txt");
-        t!(s: "hi\\there.txt", with_filestem, "\\", "hi\\.txt");
-        t!(s: "hi\\there.txt", with_filestem, "foo\\bar", "hi\\foo\\bar.txt");
-        t!(s: "hi\\there.foo.txt", with_filestem, "here", "hi\\here.txt");
-        t!(s: "hi\\there", with_filestem, "here", "hi\\here");
-        t!(s: "hi\\there", with_filestem, "", "hi");
-        t!(s: "hi", with_filestem, "", ".");
-        t!(s: "\\hi", with_filestem, "", "\\");
-        t!(s: "hi\\there", with_filestem, "..", ".");
-        t!(s: "hi\\there", with_filestem, ".", "hi");
-        t!(s: "hi\\there.", with_filestem, "foo", "hi\\foo.");
-        t!(s: "hi\\there.", with_filestem, "", "hi");
-        t!(s: "hi\\there.", with_filestem, ".", ".");
-        t!(s: "hi\\there.", with_filestem, "..", "hi\\...");
-        t!(s: "\\", with_filestem, "foo", "\\foo");
-        t!(s: ".", with_filestem, "foo", "foo");
-        t!(s: "hi\\there..", with_filestem, "here", "hi\\here.");
-        t!(s: "hi\\there..", with_filestem, "", "hi");
-        // filestem setter calls filename setter internally, no need for extended tests
-
         t!(s: "hi\\there.txt", with_extension, "exe", "hi\\there.exe");
         t!(s: "hi\\there.txt", with_extension, "", "hi\\there");
         t!(s: "hi\\there.txt", with_extension, ".", "hi\\there..");
@@ -2093,16 +1943,6 @@ mod tests {
             )
         )
 
-        t!(v: b!("a\\b\\c"), set_dirname, with_dirname, b!("d"));
-        t!(v: b!("a\\b\\c"), set_dirname, with_dirname, b!("d\\e"));
-        t!(s: "a\\b\\c", set_dirname, with_dirname, "d");
-        t!(s: "a\\b\\c", set_dirname, with_dirname, "d\\e");
-        t!(s: "\\", set_dirname, with_dirname, "foo");
-        t!(s: "\\foo", set_dirname, with_dirname, "bar");
-        t!(s: "a\\b\\c", set_dirname, with_dirname, "");
-        t!(s: "..\\..", set_dirname, with_dirname, "x");
-        t!(s: "foo", set_dirname, with_dirname, "..\\..");
-
         t!(v: b!("a\\b\\c"), set_filename, with_filename, b!("d"));
         t!(v: b!("\\"), set_filename, with_filename, b!("foo"));
         t!(s: "a\\b\\c", set_filename, with_filename, "d");
@@ -2111,13 +1951,6 @@ mod tests {
         t!(s: "a\\b", set_filename, with_filename, "");
         t!(s: "a", set_filename, with_filename, "");
 
-        t!(v: b!("hi\\there.txt"), set_filestem, with_filestem, b!("here"));
-        t!(s: "hi\\there.txt", set_filestem, with_filestem, "here");
-        t!(s: "hi\\there.", set_filestem, with_filestem, "here");
-        t!(s: "hi\\there", set_filestem, with_filestem, "here");
-        t!(s: "hi\\there.txt", set_filestem, with_filestem, "");
-        t!(s: "hi\\there", set_filestem, with_filestem, "");
-
         t!(v: b!("hi\\there.txt"), set_extension, with_extension, b!("exe"));
         t!(s: "hi\\there.txt", set_extension, with_extension, "exe");
         t!(s: "hi\\there.", set_extension, with_extension, "txt");
@@ -2130,33 +1963,6 @@ mod tests {
         // will suffice. No need for the full set of prefix tests.
     }
 
-    #[test]
-    fn test_add_extension() {
-        macro_rules! t(
-            (s: $path:expr, $ext:expr, $exp:expr) => (
-                {
-                    let mut path = Path::new($path);
-                    path.add_extension($ext);
-                    assert_eq!(path.as_str(), Some($exp));
-                }
-            );
-            (v: $path:expr, $ext:expr, $exp:expr) => (
-                {
-                    let mut path = Path::new($path);
-                    path.add_extension($ext);
-                    assert_eq!(path.as_vec(), $exp);
-                }
-            )
-        )
-
-        t!(v: b!("hi\\there.txt"), b!("foo"), b!("hi\\there.txt.foo"));
-        t!(v: b!("hi\\there"), b!("bar"), b!("hi\\there.bar"));
-        t!(v: b!("\\"), b!("foo"), b!("\\"));
-        t!(v: b!("."), b!("foo"), b!("."));
-        t!(s: "hi\\there.", "foo", "hi\\there..foo");
-        t!(s: "hi\\there.txt", "", "hi\\there.txt");
-    }
-
     #[test]
     fn test_getters() {
         macro_rules! t(
@@ -2211,7 +2017,7 @@ mod tests {
     }
 
     #[test]
-    fn test_dir_file_path() {
+    fn test_dir_path() {
         t!(s: Path::new("hi\\there").dir_path(), "hi");
         t!(s: Path::new("hi").dir_path(), ".");
         t!(s: Path::new("\\hi").dir_path(), "\\");
@@ -2219,24 +2025,7 @@ mod tests {
         t!(s: Path::new("..").dir_path(), "..");
         t!(s: Path::new("..\\..").dir_path(), "..\\..");
 
-        macro_rules! t(
+        // dir_path is just dirname interpreted as a path.
-            ($path:expr, $exp:expr) => (
-                {
-                    let path = $path;
-                    let left = path.and_then_ref(|p| p.as_str());
-                    assert_eq!(left, $exp);
-                }
-            );
-        )
-
-        t!(Path::new("hi\\there").file_path(), Some("there"));
-        t!(Path::new("hi").file_path(), Some("hi"));
-        t!(Path::new(".").file_path(), None);
-        t!(Path::new("\\").file_path(), None);
-        t!(Path::new("..").file_path(), None);
-        t!(Path::new("..\\..").file_path(), None);
-
-        // dir_path and file_path are just dirname and filename interpreted as paths.
         // No need for extended tests
     }