auto merge of #7996 : erickt/rust/cleanup-strs, r=erickt

This is a cleanup pull request that does:

* removes `os::as_c_charp`
* moves `str::as_buf` and `str::as_c_str` into `StrSlice`
* converts some functions from `StrSlice::as_buf` to `StrSlice::as_c_str`
* renames `StrSlice::as_buf` to `StrSlice::as_imm_buf` (and adds `StrSlice::as_mut_buf` to match `vec.rs`.
* renames `UniqueStr::as_bytes_with_null_consume` to `UniqueStr::to_bytes`
* and other misc cleanups and minor optimizations

14 files changed, 258 insertions, 315 deletions

diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 6ceaf5caea3..05a5184ccba 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -63,7 +63,7 @@ use iterator::IteratorUtil;
 use ptr;
 use result;
 use str;
-use str::StrSlice;
+use str::{StrSlice, OwnedStr};
 use to_str::ToStr;
 use uint;
 use vec;
@@ -763,7 +763,7 @@ impl<T:Reader> ReaderUtil for T {
     fn read_lines(&self) -> ~[~str] {
         do vec::build |push| {
             for self.each_line |line| {
-                push(str::to_owned(line));
+                push(line.to_owned());
             }
         }
     }
@@ -1031,17 +1031,16 @@ pub fn stdin() -> @Reader {
 }
 
 pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
-    unsafe {
-        let f = os::as_c_charp(path.to_str(), |pathbuf| {
-            os::as_c_charp("r", |modebuf|
-                libc::fopen(pathbuf, modebuf)
-            )
-        });
-        return if f as uint == 0u { result::Err(~"error opening "
-                                                + path.to_str()) }
-        else {
-            result::Ok(FILE_reader(f, true))
+    let f = do path.to_str().as_c_str |pathbuf| {
+        do "r".as_c_str |modebuf| {
+            unsafe { libc::fopen(pathbuf, modebuf as *libc::c_char) }
         }
+    };
+
+    if f as uint == 0u {
+        result::Err(~"error opening " + path.to_str())
+    } else {
+        result::Ok(FILE_reader(f, true))
     }
 }
 
@@ -1282,7 +1281,7 @@ pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
         }
     }
     let fd = unsafe {
-        do os::as_c_charp(path.to_str()) |pathbuf| {
+        do path.to_str().as_c_str |pathbuf| {
             libc::open(pathbuf, fflags,
                        (S_IRUSR | S_IWUSR) as c_int)
         }
@@ -1567,8 +1566,8 @@ pub fn file_writer(path: &Path, flags: &[FileFlag]) -> Result<@Writer, ~str> {
 // FIXME: fileflags // #2004
 pub fn buffered_file_writer(path: &Path) -> Result<@Writer, ~str> {
     unsafe {
-        let f = do os::as_c_charp(path.to_str()) |pathbuf| {
-            do os::as_c_charp("w") |modebuf| {
+        let f = do path.to_str().as_c_str |pathbuf| {
+            do "w".as_c_str |modebuf| {
                 libc::fopen(pathbuf, modebuf)
             }
         };
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index f5e5dbb3dbf..c4fee908266 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -50,7 +50,6 @@ use iterator::Iterator;
 use str::StrSlice;
 use clone::DeepClone;
 
-#[cfg(test)] use str;
 #[cfg(test)] use iterator::IteratorUtil;
 
 /// The option type
@@ -446,10 +445,10 @@ fn test_unwrap_ptr() {
 #[test]
 fn test_unwrap_str() {
     let x = ~"test";
-    let addr_x = str::as_buf(x, |buf, _len| buf);
+    let addr_x = x.as_imm_buf(|buf, _len| buf);
     let opt = Some(x);
     let y = opt.unwrap();
-    let addr_y = str::as_buf(y, |buf, _len| buf);
+    let addr_y = y.as_imm_buf(|buf, _len| buf);
     assert_eq!(addr_x, addr_y);
 }
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 5981926fce3..142021be471 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -87,13 +87,8 @@ pub fn getcwd() -> Path {
 
 // FIXME: move these to str perhaps? #2620
 
-pub fn as_c_charp<T>(s: &str, f: &fn(*c_char) -> T) -> T {
-    str::as_c_str(s, |b| f(b as *c_char))
-}
-
-pub fn fill_charp_buf(f: &fn(*mut c_char, size_t) -> bool)
-    -> Option<~str> {
-    let mut buf = vec::from_elem(TMPBUF_SZ, 0u8 as c_char);
+pub fn fill_charp_buf(f: &fn(*mut c_char, size_t) -> bool) -> Option<~str> {
+    let mut buf = [0 as c_char, .. TMPBUF_SZ];
     do buf.as_mut_buf |b, sz| {
         if f(b, sz as size_t) {
             unsafe {
@@ -247,12 +242,11 @@ pub fn env() -> ~[(~str,~str)] {
 pub fn getenv(n: &str) -> Option<~str> {
     unsafe {
         do with_env_lock {
-            let s = str::as_c_str(n, |s| libc::getenv(s));
+            let s = n.as_c_str(|s| libc::getenv(s as *libc::c_char));
             if ptr::null::<u8>() == cast::transmute(s) {
-                None::<~str>
+                None
             } else {
-                let s = cast::transmute(s);
-                Some::<~str>(str::raw::from_buf(s))
+                Some(str::raw::from_buf(cast::transmute(s)))
             }
         }
     }
@@ -281,8 +275,8 @@ pub fn getenv(n: &str) -> Option<~str> {
 pub fn setenv(n: &str, v: &str) {
     unsafe {
         do with_env_lock {
-            do str::as_c_str(n) |nbuf| {
-                do str::as_c_str(v) |vbuf| {
+            do n.to_str().as_c_str |nbuf| {
+                do v.to_str().as_c_str |vbuf| {
                     libc::funcs::posix01::unistd::setenv(nbuf, vbuf, 1);
                 }
             }
@@ -313,7 +307,7 @@ pub fn unsetenv(n: &str) {
     fn _unsetenv(n: &str) {
         unsafe {
             do with_env_lock {
-                do str::as_c_str(n) |nbuf| {
+                do n.to_str().as_c_str |nbuf| {
                     libc::funcs::posix01::unistd::unsetenv(nbuf);
                 }
             }
@@ -335,10 +329,10 @@ pub fn unsetenv(n: &str) {
 }
 
 pub fn fdopen(fd: c_int) -> *FILE {
-    unsafe {
-        return do as_c_charp("r") |modebuf| {
+    do "r".as_c_str |modebuf| {
+        unsafe {
             libc::fdopen(fd, modebuf)
-        };
+        }
     }
 }
 
@@ -469,9 +463,9 @@ pub fn self_exe_path() -> Option<Path> {
             use libc::funcs::posix01::unistd::readlink;
 
             let mut path_str = str::with_capacity(TMPBUF_SZ);
-            let len = do str::as_c_str(path_str) |buf| {
+            let len = do path_str.as_c_str |buf| {
                 let buf = buf as *mut c_char;
-                do as_c_charp("/proc/self/exe") |proc_self_buf| {
+                do "/proc/self/exe".as_c_str |proc_self_buf| {
                     readlink(proc_self_buf, buf, TMPBUF_SZ as size_t)
                 }
             };
@@ -602,7 +596,7 @@ pub fn walk_dir(p: &Path, f: &fn(&Path) -> bool) -> bool {
 /// Indicates whether a path represents a directory
 pub fn path_is_dir(p: &Path) -> bool {
     unsafe {
-        do str::as_c_str(p.to_str()) |buf| {
+        do p.to_str().as_c_str |buf| {
             rustrt::rust_path_is_dir(buf) != 0 as c_int
         }
     }
@@ -611,7 +605,7 @@ pub fn path_is_dir(p: &Path) -> bool {
 /// Indicates whether a path exists
 pub fn path_exists(p: &Path) -> bool {
     unsafe {
-        do str::as_c_str(p.to_str()) |buf| {
+        do p.to_str().as_c_str |buf| {
             rustrt::rust_path_exists(buf) != 0 as c_int
         }
     }
@@ -654,9 +648,9 @@ pub fn make_dir(p: &Path, mode: c_int) -> bool {
 
     #[cfg(unix)]
     fn mkdir(p: &Path, mode: c_int) -> bool {
-        unsafe {
-            do as_c_charp(p.to_str()) |c| {
-                libc::mkdir(c, mode as libc::mode_t) == (0 as c_int)
+        do p.to_str().as_c_str |buf| {
+            unsafe {
+                libc::mkdir(buf, mode as libc::mode_t) == (0 as c_int)
             }
         }
     }
@@ -830,10 +824,10 @@ pub fn remove_dir(p: &Path) -> bool {
 
     #[cfg(unix)]
     fn rmdir(p: &Path) -> bool {
-        unsafe {
-            return do as_c_charp(p.to_str()) |buf| {
+        do p.to_str().as_c_str |buf| {
+            unsafe {
                 libc::rmdir(buf) == (0 as c_int)
-            };
+            }
         }
     }
 }
@@ -855,10 +849,10 @@ pub fn change_dir(p: &Path) -> bool {
 
     #[cfg(unix)]
     fn chdir(p: &Path) -> bool {
-        unsafe {
-            return do as_c_charp(p.to_str()) |buf| {
+        do p.to_str().as_c_str |buf| {
+            unsafe {
                 libc::chdir(buf) == (0 as c_int)
-            };
+            }
         }
     }
 }
@@ -883,8 +877,8 @@ pub fn copy_file(from: &Path, to: &Path) -> bool {
     #[cfg(unix)]
     fn do_copy_file(from: &Path, to: &Path) -> bool {
         unsafe {
-            let istream = do as_c_charp(from.to_str()) |fromp| {
-                do as_c_charp("rb") |modebuf| {
+            let istream = do from.to_str().as_c_str |fromp| {
+                do "rb".as_c_str |modebuf| {
                     libc::fopen(fromp, modebuf)
                 }
             };
@@ -895,8 +889,8 @@ pub fn copy_file(from: &Path, to: &Path) -> bool {
             let from_mode = from.get_mode().expect("copy_file: couldn't get permissions \
                                                     for source file");
 
-            let ostream = do as_c_charp(to.to_str()) |top| {
-                do as_c_charp("w+b") |modebuf| {
+            let ostream = do to.to_str().as_c_str |top| {
+                do "w+b".as_c_str |modebuf| {
                     libc::fopen(top, modebuf)
                 }
             };
@@ -928,7 +922,7 @@ pub fn copy_file(from: &Path, to: &Path) -> bool {
             fclose(ostream);
 
             // Give the new file the old file's permissions
-            if do str::as_c_str(to.to_str()) |to_buf| {
+            if do to.to_str().as_c_str |to_buf| {
                 libc::chmod(to_buf, from_mode as libc::mode_t)
             } != 0 {
                 return false; // should be a condition...
@@ -955,9 +949,9 @@ pub fn remove_file(p: &Path) -> bool {
     #[cfg(unix)]
     fn unlink(p: &Path) -> bool {
         unsafe {
-            return do as_c_charp(p.to_str()) |buf| {
+            do p.to_str().as_c_str |buf| {
                 libc::unlink(buf) == (0 as c_int)
-            };
+            }
         }
     }
 }
@@ -1294,7 +1288,7 @@ pub fn glob(pattern: &str) -> ~[Path] {
     }
 
     let mut g = default_glob_t();
-    do str::as_c_str(pattern) |c_pattern| {
+    do pattern.as_c_str |c_pattern| {
         unsafe { libc::glob(c_pattern, 0, ptr::null(), &mut g) }
     };
     do(|| {
@@ -1703,7 +1697,7 @@ mod tests {
     use libc;
     use option::Some;
     use option;
-    use os::{as_c_charp, env, getcwd, getenv, make_absolute, real_args};
+    use os::{env, getcwd, getenv, make_absolute, real_args};
     use os::{remove_file, setenv, unsetenv};
     use os;
     use path::Path;
@@ -1941,8 +1935,8 @@ mod tests {
           let out = tempdir.push("out.txt");
 
           /* Write the temp input file */
-            let ostream = do as_c_charp(in.to_str()) |fromp| {
-                do as_c_charp("w+b") |modebuf| {
+            let ostream = do in.to_str().as_c_str |fromp| {
+                do "w+b".as_c_str |modebuf| {
                     libc::fopen(fromp, modebuf)
                 }
           };
@@ -2020,16 +2014,16 @@ mod tests {
            }
         }
 
-        let p = tmpdir().push("mmap_file.tmp");
+        let path = tmpdir().push("mmap_file.tmp");
         let size = page_size() * 2;
-        remove_file(&p);
+        remove_file(&path);
 
         let fd = unsafe {
-            let fd = do as_c_charp(p.to_str()) |path| {
+            let fd = do path.to_str().as_c_str |path| {
                 open(path, O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR)
             };
             lseek_(fd, size);
-            do as_c_charp("x") |x| {
+            do "x".as_c_str |x| {
                 assert!(write(fd, x as *c_void, 1) == 1);
             }
             fd
diff --git a/src/libstd/path.rs b/src/libstd/path.rs
index 3ec3407b1cc..ef7a055b0e7 100644
--- a/src/libstd/path.rs
+++ b/src/libstd/path.rs
@@ -23,7 +23,6 @@ use iterator::IteratorUtil;
 use libc;
 use option::{None, Option, Some};
 use str::{OwnedStr, Str, StrSlice, StrVector};
-use str;
 use to_str::ToStr;
 use ascii::{AsciiCast, AsciiStr};
 use vec::{OwnedVector, ImmutableVector};
@@ -342,13 +341,11 @@ mod stat {
 #[cfg(target_os = "win32")]
 impl WindowsPath {
     pub fn stat(&self) -> Option<libc::stat> {
-        unsafe {
-             do str::as_c_str(self.to_str()) |buf| {
-                let mut st = stat::arch::default_stat();
-                match libc::stat(buf, &mut st) {
-                    0 => Some(st),
-                    _ => None,
-                }
+        do self.to_str().as_c_str |buf| {
+            let mut st = stat::arch::default_stat();
+            match unsafe { libc::stat(buf, &mut st) } {
+                0 => Some(st),
+                _ => None,
             }
         }
     }
@@ -378,13 +375,11 @@ impl WindowsPath {
 #[cfg(not(target_os = "win32"))]
 impl PosixPath {
     pub fn stat(&self) -> Option<libc::stat> {
-        unsafe {
-             do str::as_c_str(self.to_str()) |buf| {
-                let mut st = stat::arch::default_stat();
-                match libc::stat(buf, &mut st) {
-                    0 => Some(st),
-                    _ => None,
-                }
+        do self.to_str().as_c_str |buf| {
+            let mut st = stat::arch::default_stat();
+            match unsafe { libc::stat(buf as *libc::c_char, &mut st) } {
+                0 => Some(st),
+                _ => None,
             }
         }
     }
@@ -458,13 +453,11 @@ impl PosixPath {
 #[cfg(unix)]
 impl PosixPath {
     pub fn lstat(&self) -> Option<libc::stat> {
-        unsafe {
-            do str::as_c_str(self.to_str()) |buf| {
-                let mut st = stat::arch::default_stat();
-                match libc::lstat(buf, &mut st) {
-                    0 => Some(st),
-                    _ => None,
-                }
+        do self.to_str().as_c_str |buf| {
+            let mut st = stat::arch::default_stat();
+            match unsafe { libc::lstat(buf, &mut st) } {
+                0 => Some(st),
+                _ => None,
             }
         }
     }
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index e3e042a4947..0d9446bcfca 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -62,7 +62,7 @@ pub use path::PosixPath;
 pub use path::WindowsPath;
 pub use ptr::RawPtr;
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, ToBytesConsume};
-pub use str::{Str, StrVector, StrSlice, OwnedStr, StrUtil, NullTerminatedStr};
+pub use str::{Str, StrVector, StrSlice, OwnedStr, NullTerminatedStr};
 pub use from_str::{FromStr};
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, ToStrConsume};
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index c2b59d51347..29564bd9728 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -461,17 +461,13 @@ pub mod ptr_tests {
 
     #[test]
     fn test_position() {
-        use str::as_c_str;
         use libc::c_char;
 
         let s = ~"hello";
         unsafe {
-            assert!(2u == as_c_str(s, |p| position(p,
-                                                   |c| *c == 'l' as c_char)));
-            assert!(4u == as_c_str(s, |p| position(p,
-                                                   |c| *c == 'o' as c_char)));
-            assert!(5u == as_c_str(s, |p| position(p,
-                                                   |c| *c == 0 as c_char)));
+            assert!(2u == s.as_c_str(|p| position(p, |c| *c == 'l' as c_char)));
+            assert!(4u == s.as_c_str(|p| position(p, |c| *c == 'o' as c_char)));
+            assert!(5u == s.as_c_str(|p| position(p, |c| *c == 0 as c_char)));
         }
     }
 
@@ -480,9 +476,9 @@ pub mod ptr_tests {
         let s0 = ~"hello";
         let s1 = ~"there";
         let s2 = ~"thing";
-        do str::as_c_str(s0) |p0| {
-            do str::as_c_str(s1) |p1| {
-                do str::as_c_str(s2) |p2| {
+        do s0.as_c_str |p0| {
+            do s1.as_c_str |p1| {
+                do s2.as_c_str |p2| {
                     let v = ~[p0, p1, p2, null()];
                     do v.as_imm_buf |vp, len| {
                         assert_eq!(unsafe { buf_len(vp) }, 3u);
diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs
index 60df2d5c11b..1a468fcf215 100644
--- a/src/libstd/rt/borrowck.rs
+++ b/src/libstd/rt/borrowck.rs
@@ -16,7 +16,7 @@ use managed::raw::BoxRepr;
 use option::{Option, None, Some};
 use uint;
 use str;
-use str::OwnedStr;
+use str::{OwnedStr, StrSlice};
 use sys;
 use vec::ImmutableVector;
 
@@ -76,7 +76,7 @@ unsafe fn fail_borrowed(box: *mut BoxRepr, file: *c_char, line: size_t) {
     match try_take_task_borrow_list() {
         None => { // not recording borrows
             let msg = "borrowed";
-            do str::as_buf(msg) |msg_p, _| {
+            do msg.as_c_str |msg_p| {
                 sys::begin_unwind_(msg_p as *c_char, file, line);
             }
         }
@@ -92,7 +92,7 @@ unsafe fn fail_borrowed(box: *mut BoxRepr, file: *c_char, line: size_t) {
                     sep = " and at ";
                 }
             }
-            do str::as_buf(msg) |msg_p, _| {
+            do msg.as_c_str |msg_p| {
                 sys::begin_unwind_(msg_p as *c_char, file, line)
             }
         }
@@ -231,7 +231,7 @@ pub unsafe fn unrecord_borrow(a: *u8, old_ref_count: uint,
             let br = borrow_list.pop();
             if br.box != a || br.file != file || br.line != line {
                 let err = fmt!("wrong borrow found, br=%?", br);
-                do str::as_buf(err) |msg_p, _| {
+                do err.as_c_str |msg_p| {
                     sys::begin_unwind_(msg_p as *c_char, file, line)
                 }
             }
diff --git a/src/libstd/rt/logging.rs b/src/libstd/rt/logging.rs
index 84186180aa6..11d11daebc2 100644
--- a/src/libstd/rt/logging.rs
+++ b/src/libstd/rt/logging.rs
@@ -46,17 +46,15 @@ impl Logger for StdErrLogger {
 /// per-module global logging flags based on the logging spec
 pub fn init(crate_map: *u8) {
     use os;
-    use str;
+    use str::StrSlice;
     use ptr;
     use option::{Some, None};
 
     let log_spec = os::getenv("RUST_LOG");
     match log_spec {
         Some(spec) => {
-            do str::as_c_str(spec) |s| {
-                unsafe {
-                    rust_update_log_settings(crate_map, s);
-                }
+            do spec.as_c_str |buf| {
+                unsafe { rust_update_log_settings(crate_map, buf) }
             }
         }
         None => {
diff --git a/src/libstd/rt/uv/uvll.rs b/src/libstd/rt/uv/uvll.rs
index 62bf8f27af9..1f27a577684 100644
--- a/src/libstd/rt/uv/uvll.rs
+++ b/src/libstd/rt/uv/uvll.rs
@@ -382,12 +382,12 @@ pub unsafe fn as_sockaddr_in6(addr: *sockaddr) -> *sockaddr_in6 {
 }
 
 pub unsafe fn malloc_ip4_addr(ip: &str, port: int) -> *sockaddr_in {
-    do str::as_c_str(ip) |ip_buf| {
+    do ip.as_c_str |ip_buf| {
         rust_uv_ip4_addrp(ip_buf as *u8, port as libc::c_int)
     }
 }
 pub unsafe fn malloc_ip6_addr(ip: &str, port: int) -> *sockaddr_in6 {
-    do str::as_c_str(ip) |ip_buf| {
+    do ip.as_c_str |ip_buf| {
         rust_uv_ip6_addrp(ip_buf as *u8, port as libc::c_int)
     }
 }
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index c0b46ba273d..2a8d29214fa 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -23,7 +23,6 @@ use option::{Some, None};
 use os;
 use prelude::*;
 use ptr;
-use str;
 use task;
 use vec::ImmutableVector;
 
@@ -507,7 +506,7 @@ fn spawn_process_os(prog: &str, args: &[~str],
 
         do with_envp(env) |envp| {
             do with_dirp(dir) |dirp| {
-                do str::as_c_str(cmd) |cmdp| {
+                do cmd.as_c_str |cmdp| {
                     let created = CreateProcessA(ptr::null(), cast::transmute(cmdp),
                                                  ptr::mut_null(), ptr::mut_null(), TRUE,
                                                  0, envp, dirp, &mut si, &mut pi);
@@ -696,12 +695,12 @@ fn spawn_process_os(prog: &str, args: &[~str],
 #[cfg(unix)]
 fn with_argv<T>(prog: &str, args: &[~str],
                 cb: &fn(**libc::c_char) -> T) -> T {
-    let mut argptrs = ~[str::as_c_str(prog, |b| b)];
+    let mut argptrs = ~[prog.as_c_str(|b| b)];
     let mut tmps = ~[];
     for args.iter().advance |arg| {
         let t = @(*arg).clone();
         tmps.push(t);
-        argptrs.push(str::as_c_str(*t, |b| b));
+        argptrs.push(t.as_c_str(|b| b));
     }
     argptrs.push(ptr::null());
     argptrs.as_imm_buf(|buf, _len| cb(buf))
@@ -723,7 +722,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*c_void) -> T) -> T {
                 &(ref k, ref v) => {
                     let kv = @fmt!("%s=%s", *k, *v);
                     tmps.push(kv);
-                    ptrs.push(str::as_c_str(*kv, |b| b));
+                    ptrs.push(kv.as_c_str(|b| b));
                 }
             }
         }
@@ -747,7 +746,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*mut c_void) -> T) -> T {
         let mut blk = ~[];
         for es.iter().advance |pair| {
             let kv = fmt!("%s=%s", pair.first(), pair.second());
-            blk.push_all(kv.as_bytes_with_null_consume());
+            blk.push_all(kv.to_bytes_with_null());
         }
         blk.push(0);
         blk.as_imm_buf(|p, _len|
@@ -761,7 +760,7 @@ fn with_envp<T>(env: Option<&[(~str, ~str)]>, cb: &fn(*mut c_void) -> T) -> T {
 fn with_dirp<T>(d: Option<&Path>,
                 cb: &fn(*libc::c_char) -> T) -> T {
     match d {
-      Some(dir) => str::as_c_str(dir.to_str(), cb),
+      Some(dir) => dir.to_str().as_c_str(cb),
       None => cb(ptr::null())
     }
 }
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 5b83112fe6b..636bbc48f8e 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -17,7 +17,6 @@
  */
 
 use at_vec;
-use cast::transmute;
 use cast;
 use char;
 use char::Char;
@@ -33,7 +32,7 @@ use ptr::RawPtr;
 use to_str::ToStr;
 use uint;
 use vec;
-use vec::{OwnedVector, OwnedCopyableVector, ImmutableVector};
+use vec::{OwnedVector, OwnedCopyableVector, ImmutableVector, MutableVector};
 
 /*
 Section: Conditions
@@ -121,23 +120,17 @@ pub fn from_bytes_slice<'a>(vector: &'a [u8]) -> &'a str {
     }
 }
 
-/// Copy a slice into a new unique str
-#[inline]
-pub fn to_owned(s: &str) -> ~str {
-    unsafe { raw::slice_bytes_owned(s, 0, s.len()) }
-}
-
 impl ToStr for ~str {
     #[inline]
-    fn to_str(&self) -> ~str { to_owned(*self) }
+    fn to_str(&self) -> ~str { self.to_owned() }
 }
 impl<'self> ToStr for &'self str {
     #[inline]
-    fn to_str(&self) -> ~str { to_owned(*self) }
+    fn to_str(&self) -> ~str { self.to_owned() }
 }
 impl ToStr for @str {
     #[inline]
-    fn to_str(&self) -> ~str { to_owned(*self) }
+    fn to_str(&self) -> ~str { self.to_owned() }
 }
 
 /**
@@ -187,15 +180,13 @@ impl<'self, S: Str> StrVector for &'self [S] {
 
         let len = self.iter().transform(|s| s.as_slice().len()).sum();
 
-        let mut s = ~"";
-
-        s.reserve(len);
+        let mut s = with_capacity(len);
 
         unsafe {
-            do as_buf(s) |buf, _| {
-                let mut buf = ::cast::transmute_mut_unsafe(buf);
+            do s.as_mut_buf |buf, _| {
+                let mut buf = buf;
                 for self.iter().advance |ss| {
-                    do as_buf(ss.as_slice()) |ssbuf, sslen| {
+                    do ss.as_slice().as_imm_buf |ssbuf, sslen| {
                         let sslen = sslen - 1;
                         ptr::copy_memory(buf, ssbuf, sslen);
                         buf = buf.offset(sslen);
@@ -223,12 +214,12 @@ impl<'self, S: Str> StrVector for &'self [S] {
         s.reserve(len);
 
         unsafe {
-            do as_buf(s) |buf, _| {
-                do as_buf(sep) |sepbuf, seplen| {
+            do s.as_mut_buf |buf, _| {
+                do sep.as_imm_buf |sepbuf, seplen| {
                     let seplen = seplen - 1;
                     let mut buf = ::cast::transmute_mut_unsafe(buf);
                     for self.iter().advance |ss| {
-                        do as_buf(ss.as_slice()) |ssbuf, sslen| {
+                        do ss.as_slice().as_imm_buf |ssbuf, sslen| {
                             let sslen = sslen - 1;
                             if first {
                                 first = false;
@@ -534,8 +525,8 @@ Section: Comparing strings
 #[lang="str_eq"]
 #[inline]
 pub fn eq_slice(a: &str, b: &str) -> bool {
-    do as_buf(a) |ap, alen| {
-        do as_buf(b) |bp, blen| {
+    do a.as_imm_buf |ap, alen| {
+        do b.as_imm_buf |bp, blen| {
             if (alen != blen) { false }
             else {
                 unsafe {
@@ -551,8 +542,8 @@ pub fn eq_slice(a: &str, b: &str) -> bool {
 #[cfg(test)]
 #[inline]
 pub fn eq_slice(a: &str, b: &str) -> bool {
-    do as_buf(a) |ap, alen| {
-        do as_buf(b) |bp, blen| {
+    do a.as_imm_buf |ap, alen| {
+        do b.as_imm_buf |bp, blen| {
             if (alen != blen) { false }
             else {
                 unsafe {
@@ -685,6 +676,7 @@ pub fn from_utf16(v: &[u16]) -> ~str {
  * Allocates a new string with the specified capacity. The string returned is
  * the empty string, but has capacity for much more.
  */
+#[inline]
 pub fn with_capacity(capacity: uint) -> ~str {
     let mut buf = ~"";
     buf.reserve(capacity);
@@ -774,75 +766,13 @@ static TAG_THREE_B: uint = 224u;
 static MAX_THREE_B: uint = 65536u;
 static TAG_FOUR_B: uint = 240u;
 
-/**
- * A dummy trait to hold all the utility methods that we implement on strings.
- */
-pub trait StrUtil {
-    /**
-     * Work with the byte buffer of a string as a null-terminated C string.
-     *
-     * Allows for unsafe manipulation of strings, which is useful for foreign
-     * interop. This is similar to `str::as_buf`, but guarantees null-termination.
-     * If the given slice is not already null-terminated, this function will
-     * allocate a temporary, copy the slice, null terminate it, and pass
-     * that instead.
-     *
-     * # Example
-     *
-     * ~~~ {.rust}
-     * let s = "PATH".as_c_str(|path| libc::getenv(path));
-     * ~~~
-     */
-    fn as_c_str<T>(self, f: &fn(*libc::c_char) -> T) -> T;
-}
-
-impl<'self> StrUtil for &'self str {
-    #[inline]
-    fn as_c_str<T>(self, f: &fn(*libc::c_char) -> T) -> T {
-        do as_buf(self) |buf, len| {
-            // NB: len includes the trailing null.
-            assert!(len > 0);
-            if unsafe { *(ptr::offset(buf,len-1)) != 0 } {
-                to_owned(self).as_c_str(|s| f(s))
-            } else {
-                f(buf as *libc::c_char)
-            }
-        }
-    }
-}
-
-/**
- * Deprecated. Use the `as_c_str` method on strings instead.
- */
-#[inline]
-pub fn as_c_str<T>(s: &str, f: &fn(*libc::c_char) -> T) -> T {
-    s.as_c_str(f)
-}
-
-/**
- * Work with the byte buffer and length of a slice.
- *
- * The given length is one byte longer than the 'official' indexable
- * length of the string. This is to permit probing the byte past the
- * indexable area for a null byte, as is the case in slices pointing
- * to full strings, or suffixes of them.
- */
-#[inline]
-pub fn as_buf<T>(s: &str, f: &fn(*u8, uint) -> T) -> T {
-    unsafe {
-        let v : *(*u8,uint) = transmute(&s);
-        let (buf,len) = *v;
-        f(buf, len)
-    }
-}
-
 /// Unsafe operations
 pub mod raw {
     use cast;
     use libc;
     use ptr;
     use str::raw;
-    use str::{as_buf, is_utf8};
+    use str::{is_utf8};
     use vec;
     use vec::MutableVector;
 
@@ -930,36 +860,9 @@ pub mod raw {
      * If begin is greater than end.
      * If end is greater than the length of the string.
      */
-    pub unsafe fn slice_bytes_owned(s: &str, begin: uint, end: uint) -> ~str {
-        do as_buf(s) |sbuf, n| {
-            assert!((begin <= end));
-            assert!((end <= n));
-
-            let mut v = vec::with_capacity(end - begin + 1u);
-            do v.as_imm_buf |vbuf, _vlen| {
-                let vbuf = ::cast::transmute_mut_unsafe(vbuf);
-                let src = ptr::offset(sbuf, begin);
-                ptr::copy_memory(vbuf, src, end - begin);
-            }
-            vec::raw::set_len(&mut v, end - begin);
-            v.push(0u8);
-            ::cast::transmute(v)
-        }
-    }
-
-    /**
-     * Takes a bytewise (not UTF-8) slice from a string.
-     *
-     * Returns the substring from [`begin`..`end`).
-     *
-     * # Failure
-     *
-     * If begin is greater than end.
-     * If end is greater than the length of the string.
-     */
     #[inline]
     pub unsafe fn slice_bytes(s: &str, begin: uint, end: uint) -> &str {
-        do as_buf(s) |sbuf, n| {
+        do s.as_imm_buf |sbuf, n| {
              assert!((begin <= end));
              assert!((end <= n));
 
@@ -972,8 +875,7 @@ pub mod raw {
     pub unsafe fn push_byte(s: &mut ~str, b: u8) {
         let new_len = s.len() + 1;
         s.reserve_at_least(new_len);
-        do as_buf(*s) |buf, len| {
-            let buf: *mut u8 = ::cast::transmute(buf);
+        do s.as_mut_buf |buf, len| {
             *ptr::mut_offset(buf, len) = b;
         }
         set_len(&mut *s, new_len);
@@ -1000,7 +902,7 @@ pub mod raw {
         let len = s.len();
         assert!((len > 0u));
         let b = s[0];
-        *s = raw::slice_bytes_owned(*s, 1u, len);
+        *s = s.slice(1, len).to_owned();
         return b;
     }
 
@@ -1193,7 +1095,7 @@ impl<'self> Str for @str {
 impl<'self> Container for &'self str {
     #[inline]
     fn len(&self) -> uint {
-        do as_buf(*self) |_p, n| { n - 1u }
+        do self.as_imm_buf |_p, n| { n - 1u }
     }
     #[inline]
     fn is_empty(&self) -> bool {
@@ -1287,6 +1189,9 @@ pub trait StrSlice<'self> {
     fn lev_distance(&self, t: &str) -> uint;
 
     fn subslice_offset(&self, inner: &str) -> uint;
+
+    fn as_imm_buf<T>(&self, f: &fn(*u8, uint) -> T) -> T;
+    fn as_c_str<T>(&self, f: &fn(*libc::c_char) -> T) -> T;
 }
 
 /// Extension methods for strings
@@ -1669,7 +1574,21 @@ impl<'self> StrSlice<'self> for &'self str {
 
     /// Copy a slice into a new unique str
     #[inline]
-    fn to_owned(&self) -> ~str { to_owned(*self) }
+    fn to_owned(&self) -> ~str {
+        do self.as_imm_buf |src, len| {
+            assert!(len > 0);
+            unsafe {
+                let mut v = vec::with_capacity(len);
+
+                do v.as_mut_buf |dst, _| {
+                    ptr::copy_memory(dst, src, len - 1);
+                }
+                vec::raw::set_len(&mut v, len - 1);
+                v.push(0u8);
+                ::cast::transmute(v)
+            }
+        }
+    }
 
     #[inline]
     fn to_managed(&self) -> @str {
@@ -1909,15 +1828,14 @@ impl<'self> StrSlice<'self> for &'self str {
 
     /// Given a string, make a new string with repeated copies of it.
     fn repeat(&self, nn: uint) -> ~str {
-        do as_buf(*self) |buf, len| {
-            let mut ret = ~"";
+        do self.as_imm_buf |buf, len| {
             // ignore the NULL terminator
             let len = len - 1;
-            ret.reserve(nn * len);
+            let mut ret = with_capacity(nn * len);
 
             unsafe {
-                do as_buf(ret) |rbuf, _len| {
-                    let mut rbuf = ::cast::transmute_mut_unsafe(rbuf);
+                do ret.as_mut_buf |rbuf, _len| {
+                    let mut rbuf = rbuf;
 
                     for nn.times {
                         ptr::copy_memory(rbuf, buf, len);
@@ -2010,8 +1928,8 @@ impl<'self> StrSlice<'self> for &'self str {
      */
     #[inline]
     fn subslice_offset(&self, inner: &str) -> uint {
-        do as_buf(*self) |a, a_len| {
-            do as_buf(inner) |b, b_len| {
+        do self.as_imm_buf |a, a_len| {
+            do inner.as_imm_buf |b, b_len| {
                 let a_start: uint;
                 let a_end: uint;
                 let b_start: uint;
@@ -2027,6 +1945,47 @@ impl<'self> StrSlice<'self> for &'self str {
         }
     }
 
+    /**
+     * Work with the byte buffer and length of a slice.
+     *
+     * The given length is one byte longer than the 'official' indexable
+     * length of the string. This is to permit probing the byte past the
+     * indexable area for a null byte, as is the case in slices pointing
+     * to full strings, or suffixes of them.
+     */
+    #[inline]
+    fn as_imm_buf<T>(&self, f: &fn(*u8, uint) -> T) -> T {
+        let v: &[u8] = unsafe { cast::transmute(*self) };
+        v.as_imm_buf(f)
+    }
+
+    /**
+     * Work with the byte buffer of a string as a null-terminated C string.
+     *
+     * Allows for unsafe manipulation of strings, which is useful for foreign
+     * interop. This is similar to `str::as_buf`, but guarantees null-termination.
+     * If the given slice is not already null-terminated, this function will
+     * allocate a temporary, copy the slice, null terminate it, and pass
+     * that instead.
+     *
+     * # Example
+     *
+     * ~~~ {.rust}
+     * let s = "PATH".as_c_str(|path| libc::getenv(path));
+     * ~~~
+     */
+    #[inline]
+    fn as_c_str<T>(&self, f: &fn(*libc::c_char) -> T) -> T {
+        do self.as_imm_buf |buf, len| {
+            // NB: len includes the trailing null.
+            assert!(len > 0);
+            if unsafe { *(ptr::offset(buf, len - 1)) != 0 } {
+                self.to_owned().as_c_str(|s| f(s))
+            } else {
+                f(buf as *libc::c_char)
+            }
+        }
+    }
 }
 
 #[allow(missing_doc)]
@@ -2069,12 +2028,23 @@ pub trait OwnedStr {
     fn pop_char(&mut self) -> char;
     fn shift_char(&mut self) -> char;
     fn unshift_char(&mut self, ch: char);
-    fn append(&self, rhs: &str) -> ~str; // FIXME #4850: this should consume self.
+    fn append(self, rhs: &str) -> ~str;
     fn reserve(&mut self, n: uint);
     fn reserve_at_least(&mut self, n: uint);
     fn capacity(&self) -> uint;
+    fn to_bytes_with_null(self) -> ~[u8];
 
-    fn as_bytes_with_null_consume(self) -> ~[u8];
+    /**
+     * Work with the mutable byte buffer and length of a slice.
+     *
+     * The given length is one byte longer than the 'official' indexable
+     * length of the string. This is to permit probing the byte past the
+     * indexable area for a null byte, as is the case in slices pointing
+     * to full strings, or suffixes of them.
+     *
+     * Make sure any mutations to this buffer keep this string valid UTF8.
+     */
+    fn as_mut_buf<T>(&mut self, f: &fn(*mut u8, uint) -> T) -> T;
 }
 
 impl OwnedStr for ~str {
@@ -2085,8 +2055,8 @@ impl OwnedStr for ~str {
             let llen = self.len();
             let rlen = rhs.len();
             self.reserve(llen + rlen);
-            do as_buf(*self) |lbuf, _llen| {
-                do as_buf(rhs) |rbuf, _rlen| {
+            do self.as_imm_buf |lbuf, _llen| {
+                do rhs.as_imm_buf |rbuf, _rlen| {
                     let dst = ptr::offset(lbuf, llen);
                     let dst = ::cast::transmute_mut_unsafe(dst);
                     ptr::copy_memory(dst, rbuf, rlen);
@@ -2103,8 +2073,8 @@ impl OwnedStr for ~str {
             let llen = self.len();
             let rlen = rhs.len();
             self.reserve_at_least(llen + rlen);
-            do as_buf(*self) |lbuf, _llen| {
-                do as_buf(rhs) |rbuf, _rlen| {
+            do self.as_imm_buf |lbuf, _llen| {
+                do rhs.as_imm_buf |rbuf, _rlen| {
                     let dst = ptr::offset(lbuf, llen);
                     let dst = ::cast::transmute_mut_unsafe(dst);
                     ptr::copy_memory(dst, rbuf, rlen);
@@ -2127,8 +2097,7 @@ impl OwnedStr for ~str {
             let new_len = len + nb;
             self.reserve_at_least(new_len);
             let off = len;
-            do as_buf(*self) |buf, _len| {
-                let buf: *mut u8 = ::cast::transmute(buf);
+            do self.as_mut_buf |buf, _len| {
                 match nb {
                     1u => {
                         *ptr::mut_offset(buf, off) = code as u8;
@@ -2178,7 +2147,7 @@ impl OwnedStr for ~str {
      */
     fn shift_char(&mut self) -> char {
         let CharRange {ch, next} = self.char_range_at(0u);
-        *self = unsafe { raw::slice_bytes_owned(*self, next, self.len()) };
+        *self = self.slice(next, self.len()).to_owned();
         return ch;
     }
 
@@ -2193,11 +2162,10 @@ impl OwnedStr for ~str {
 
     /// Concatenate two strings together.
     #[inline]
-    fn append(&self, rhs: &str) -> ~str {
-        // FIXME #4850: this should consume self, but that causes segfaults
-        let mut v = self.clone();
-        v.push_str_no_overallocate(rhs);
-        v
+    fn append(self, rhs: &str) -> ~str {
+        let mut new_str = self;
+        new_str.push_str_no_overallocate(rhs);
+        new_str
     }
 
     /**
@@ -2263,15 +2231,21 @@ impl OwnedStr for ~str {
     /// Convert to a vector of bytes. This does not allocate a new
     /// string, and includes the null terminator.
     #[inline]
-    fn as_bytes_with_null_consume(self) -> ~[u8] {
+    fn to_bytes_with_null(self) -> ~[u8] {
         unsafe { ::cast::transmute(self) }
     }
+
+    #[inline]
+    fn as_mut_buf<T>(&mut self, f: &fn(*mut u8, uint) -> T) -> T {
+        let v: &mut ~[u8] = unsafe { cast::transmute(self) };
+        v.as_mut_buf(f)
+    }
 }
 
 impl Clone for ~str {
     #[inline]
     fn clone(&self) -> ~str {
-        to_owned(*self)
+        self.to_owned()
     }
 }
 
@@ -3065,17 +3039,17 @@ mod tests {
     }
 
     #[test]
-    fn test_as_bytes_with_null_consume() {
+    fn test_to_bytes_with_null() {
         let s = ~"ศไทย中华Việt Nam";
         let v = ~[
             224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
             184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
             109, 0
         ];
-        assert_eq!((~"").as_bytes_with_null_consume(), ~[0]);
-        assert_eq!((~"abc").as_bytes_with_null_consume(),
+        assert_eq!((~"").to_bytes_with_null(), ~[0]);
+        assert_eq!((~"abc").to_bytes_with_null(),
                    ~['a' as u8, 'b' as u8, 'c' as u8, 0]);
-        assert_eq!(s.as_bytes_with_null_consume(), v);
+        assert_eq!(s.to_bytes_with_null(), v);
     }
 
     #[test]
@@ -3090,45 +3064,45 @@ mod tests {
     }
 
     #[test]
-    fn test_as_buf() {
-        let a = "Abcdefg";
-        let b = as_buf(a, |buf, _l| {
-            assert_eq!(unsafe { *buf }, 65u8);
-            100
-        });
-        assert_eq!(b, 100);
-    }
+    fn test_as_imm_buf() {
+        do "".as_imm_buf |buf, len| {
+            assert_eq!(len, 1);
+            unsafe {
+                assert_eq!(*ptr::offset(buf, 0), 0);
+            }
+        }
 
-    #[test]
-    fn test_as_buf_small() {
-        let a = "A";
-        let b = as_buf(a, |buf, _l| {
-            assert_eq!(unsafe { *buf }, 65u8);
-            100
-        });
-        assert_eq!(b, 100);
+        do "hello".as_imm_buf |buf, len| {
+            assert_eq!(len, 6);
+            unsafe {
+                assert_eq!(*ptr::offset(buf, 0), 'h' as u8);
+                assert_eq!(*ptr::offset(buf, 1), 'e' as u8);
+                assert_eq!(*ptr::offset(buf, 2), 'l' as u8);
+                assert_eq!(*ptr::offset(buf, 3), 'l' as u8);
+                assert_eq!(*ptr::offset(buf, 4), 'o' as u8);
+                assert_eq!(*ptr::offset(buf, 5), 0);
+            }
+        }
     }
 
     #[test]
-    fn test_as_buf2() {
-        unsafe {
-            let s = ~"hello";
-            let sb = as_buf(s, |b, _l| b);
-            let s_cstr = raw::from_buf(sb);
-            assert_eq!(s_cstr, s);
+    fn test_as_c_str() {
+        let a = ~"";
+        do a.as_c_str |buf| {
+            unsafe {
+                assert_eq!(*ptr::offset(buf, 0), 0);
+            }
         }
-    }
 
-    #[test]
-    fn test_as_buf_3() {
         let a = ~"hello";
-        do as_buf(a) |buf, len| {
+        do a.as_c_str |buf| {
             unsafe {
-                assert_eq!(a[0], 'h' as u8);
-                assert_eq!(*buf, 'h' as u8);
-                assert_eq!(len, 6u);
-                assert_eq!(*ptr::offset(buf,4u), 'o' as u8);
-                assert_eq!(*ptr::offset(buf,5u), 0u8);
+                assert_eq!(*ptr::offset(buf, 0), 'h' as libc::c_char);
+                assert_eq!(*ptr::offset(buf, 1), 'e' as libc::c_char);
+                assert_eq!(*ptr::offset(buf, 2), 'l' as libc::c_char);
+                assert_eq!(*ptr::offset(buf, 3), 'l' as libc::c_char);
+                assert_eq!(*ptr::offset(buf, 4), 'o' as libc::c_char);
+                assert_eq!(*ptr::offset(buf, 5), 0);
             }
         }
     }
diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs
index d50d90376ab..28cd2345aab 100644
--- a/src/libstd/sys.rs
+++ b/src/libstd/sys.rs
@@ -18,6 +18,7 @@ use io;
 use libc;
 use libc::{c_char, size_t};
 use repr;
+use str::StrSlice;
 use str;
 use unstable::intrinsics;
 
@@ -122,13 +123,9 @@ pub trait FailWithCause {
 
 impl FailWithCause for ~str {
     fn fail_with(cause: ~str, file: &'static str, line: uint) -> ! {
-        do str::as_buf(cause) |msg_buf, _msg_len| {
-            do str::as_buf(file) |file_buf, _file_len| {
-                unsafe {
-                    let msg_buf = cast::transmute(msg_buf);
-                    let file_buf = cast::transmute(file_buf);
-                    begin_unwind_(msg_buf, file_buf, line as libc::size_t)
-                }
+        do cause.as_c_str |msg_buf| {
+            do file.as_c_str |file_buf| {
+                begin_unwind_(msg_buf, file_buf, line as libc::size_t)
             }
         }
     }
@@ -136,13 +133,9 @@ impl FailWithCause for ~str {
 
 impl FailWithCause for &'static str {
     fn fail_with(cause: &'static str, file: &'static str, line: uint) -> ! {
-        do str::as_buf(cause) |msg_buf, _msg_len| {
-            do str::as_buf(file) |file_buf, _file_len| {
-                unsafe {
-                    let msg_buf = cast::transmute(msg_buf);
-                    let file_buf = cast::transmute(file_buf);
-                    begin_unwind_(msg_buf, file_buf, line as libc::size_t)
-                }
+        do cause.as_c_str |msg_buf| {
+            do file.as_c_str |file_buf| {
+                begin_unwind_(msg_buf, file_buf, line as libc::size_t)
             }
         }
     }
diff --git a/src/libstd/unstable/lang.rs b/src/libstd/unstable/lang.rs
index 92357f210a5..d96681ae803 100644
--- a/src/libstd/unstable/lang.rs
+++ b/src/libstd/unstable/lang.rs
@@ -56,8 +56,8 @@ pub fn fail_bounds_check(file: *c_char, line: size_t,
                          index: size_t, len: size_t) {
     let msg = fmt!("index out of bounds: the len is %d but the index is %d",
                     len as int, index as int);
-    do str::as_buf(msg) |p, _len| {
-        fail_(p as *c_char, file, line);
+    do msg.as_c_str |buf| {
+        fail_(buf, file, line);
     }
 }
 
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 8432f28a969..5f8a2796248 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -87,6 +87,7 @@ pub fn from_elem<T:Clone>(n_elts: uint, t: T) -> ~[T] {
 }
 
 /// Creates a new vector with a capacity of `capacity`
+#[inline]
 pub fn with_capacity<T>(capacity: uint) -> ~[T] {
     unsafe {
         if contains_managed::<T>() {
@@ -1691,7 +1692,7 @@ pub trait MutableVector<'self, T> {
     unsafe fn unsafe_mut_ref(&self, index: uint) -> *mut T;
     unsafe fn unsafe_set(&self, index: uint, val: T);
 
-    fn as_mut_buf<U>(&self, f: &fn(*mut T, uint) -> U) -> U;
+    fn as_mut_buf<U>(self, f: &fn(*mut T, uint) -> U) -> U;
 }
 
 impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
@@ -1783,12 +1784,9 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
 
     /// Similar to `as_imm_buf` but passing a `*mut T`
     #[inline]
-    fn as_mut_buf<U>(&self, f: &fn(*mut T, uint) -> U) -> U {
-        unsafe {
-            let v : *(*mut T,uint) = transmute(self);
-            let (buf,len) = *v;
-            f(buf, len / sys::nonzero_size_of::<T>())
-        }
+    fn as_mut_buf<U>(self, f: &fn(*mut T, uint) -> U) -> U {
+        let (buf, len): (*mut T, uint) = unsafe { transmute(self) };
+        f(buf, len / sys::nonzero_size_of::<T>())
     }
 
 }