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.

Author: lilyball

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 f.is_none() || bytes!("..") == f.unwrap() {
-            break;
+        if { let f = cwd.filename(); f.is_none() || f.unwrap() == bytes!("..") } {
+            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 mut q = q.as_vec().to_owned();
+    let q = p.filename().expect("path is a directory");
+    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;
     }
-    let mut p_ = p.clone();
-    if p_.pop().is_some() {
+    if p.filename().is_some() {
+        let mut p_ = p.clone();
+        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.
-    /// If `self` represents the root of the file hierarchy, None is returned.
-    fn pop(&mut self) -> Option<~[u8]>;
-    /// Pops the last path component off of `self` and returns it as a string, if possible.
-    /// `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))
-    }
+    /// Removes the last path component from the receiver.
+    /// Returns `true` if the receiver was modified, or `false` if it already
+    /// represented the root of the file hierarchy.
+    fn pop(&mut self) -> bool;
 
     /// 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.