auto merge of #13165 : sfackler/rust/io-vec, r=alexcrichton

`Reader`, `Writer`, `MemReader`, `MemWriter`, and `MultiWriter` now work with `Vec<u8>` instead of `~[u8]`. This does introduce some extra copies since `from_utf8_owned` isn't usable anymore, but I think that can't be helped until `~str`'s representation changes.

12 files changed, 115 insertions, 114 deletions

diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index 5f8a043b830..6514743c42e 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -490,7 +490,7 @@ use repr;
 use result::{Ok, Err};
 use str::StrSlice;
 use str;
-use slice::ImmutableVector;
+use slice::{Vector, ImmutableVector};
 use slice;
 
 pub use self::num::radix;
@@ -795,7 +795,7 @@ pub fn format(args: &Arguments) -> ~str {
 pub unsafe fn format_unsafe(fmt: &[rt::Piece], args: &[Argument]) -> ~str {
     let mut output = MemWriter::new();
     write_unsafe(&mut output as &mut io::Writer, fmt, args).unwrap();
-    return str::from_utf8_owned(output.unwrap()).unwrap();
+    return str::from_utf8(output.unwrap().as_slice()).unwrap().to_owned();
 }
 
 impl<'a> Formatter<'a> {
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 4da297a25fd..c9d412973ec 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -405,7 +405,7 @@ mod test {
 
     #[test]
     fn test_buffered_reader() {
-        let inner = MemReader::new(~[0, 1, 2, 3, 4]);
+        let inner = MemReader::new(vec!(0, 1, 2, 3, 4));
         let mut reader = BufferedReader::with_capacity(2, inner);
 
         let mut buf = [0, 0, 0];
@@ -502,12 +502,12 @@ mod test {
 
     #[test]
     fn test_read_until() {
-        let inner = MemReader::new(~[0, 1, 2, 1, 0]);
+        let inner = MemReader::new(vec!(0, 1, 2, 1, 0));
         let mut reader = BufferedReader::with_capacity(2, inner);
-        assert_eq!(reader.read_until(0), Ok(~[0]));
-        assert_eq!(reader.read_until(2), Ok(~[1, 2]));
-        assert_eq!(reader.read_until(1), Ok(~[1]));
-        assert_eq!(reader.read_until(8), Ok(~[0]));
+        assert_eq!(reader.read_until(0), Ok(vec!(0)));
+        assert_eq!(reader.read_until(2), Ok(vec!(1, 2)));
+        assert_eq!(reader.read_until(1), Ok(vec!(1)));
+        assert_eq!(reader.read_until(8), Ok(vec!(0)));
         assert!(reader.read_until(9).is_err());
     }
 
@@ -533,7 +533,7 @@ mod test {
 
     #[test]
     fn test_read_line() {
-        let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
+        let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc")));
         let mut reader = BufferedReader::with_capacity(2, in_buf);
         assert_eq!(reader.read_line(), Ok(~"a\n"));
         assert_eq!(reader.read_line(), Ok(~"b\n"));
@@ -543,7 +543,7 @@ mod test {
 
     #[test]
     fn test_lines() {
-        let in_buf = MemReader::new(bytes!("a\nb\nc").to_owned());
+        let in_buf = MemReader::new(Vec::from_slice(bytes!("a\nb\nc")));
         let mut reader = BufferedReader::with_capacity(2, in_buf);
         let mut it = reader.lines();
         assert_eq!(it.next(), Some(Ok(~"a\n")));
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index a9fe3be585c..f87f4a69f17 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -267,7 +267,7 @@ mod test {
 
     #[test]
     fn read_byte() {
-        let mut reader = MemReader::new(~[10]);
+        let mut reader = MemReader::new(vec!(10));
         let byte = reader.read_byte();
         assert!(byte == Ok(10));
     }
@@ -321,9 +321,9 @@ mod test {
 
     #[test]
     fn read_bytes() {
-        let mut reader = MemReader::new(~[10, 11, 12, 13]);
+        let mut reader = MemReader::new(vec!(10, 11, 12, 13));
         let bytes = reader.read_exact(4).unwrap();
-        assert!(bytes == ~[10, 11, 12, 13]);
+        assert!(bytes == vec!(10, 11, 12, 13));
     }
 
     #[test]
@@ -332,21 +332,21 @@ mod test {
             count: 0,
         };
         let bytes = reader.read_exact(4).unwrap();
-        assert!(bytes == ~[10, 11, 12, 13]);
+        assert!(bytes == vec!(10, 11, 12, 13));
     }
 
     #[test]
     fn read_bytes_eof() {
-        let mut reader = MemReader::new(~[10, 11]);
+        let mut reader = MemReader::new(vec!(10, 11));
         assert!(reader.read_exact(4).is_err());
     }
 
     #[test]
     fn push_exact() {
-        let mut reader = MemReader::new(~[10, 11, 12, 13]);
-        let mut buf = ~[8, 9];
+        let mut reader = MemReader::new(vec!(10, 11, 12, 13));
+        let mut buf = vec!(8, 9);
         reader.push_exact(&mut buf, 4).unwrap();
-        assert!(buf == ~[8, 9, 10, 11, 12, 13]);
+        assert!(buf == vec!(8, 9, 10, 11, 12, 13));
     }
 
     #[test]
@@ -354,17 +354,17 @@ mod test {
         let mut reader = PartialReader {
             count: 0,
         };
-        let mut buf = ~[8, 9];
+        let mut buf = vec!(8, 9);
         reader.push_exact(&mut buf, 4).unwrap();
-        assert!(buf == ~[8, 9, 10, 11, 12, 13]);
+        assert!(buf == vec!(8, 9, 10, 11, 12, 13));
     }
 
     #[test]
     fn push_exact_eof() {
-        let mut reader = MemReader::new(~[10, 11]);
-        let mut buf = ~[8, 9];
+        let mut reader = MemReader::new(vec!(10, 11));
+        let mut buf = vec!(8, 9);
         assert!(reader.push_exact(&mut buf, 4).is_err());
-        assert!(buf == ~[8, 9, 10, 11]);
+        assert!(buf == vec!(8, 9, 10, 11));
     }
 
     #[test]
@@ -372,9 +372,9 @@ mod test {
         let mut reader = ErroringLaterReader {
             count: 0,
         };
-        let mut buf = ~[8, 9];
+        let mut buf = vec!(8, 9);
         assert!(reader.push_exact(&mut buf, 4).is_err());
-        assert!(buf == ~[8, 9, 10]);
+        assert!(buf == vec!(8, 9, 10));
     }
 
     #[test]
@@ -383,7 +383,7 @@ mod test {
             count: 0,
         };
         let buf = reader.read_to_end().unwrap();
-        assert!(buf == ~[10, 11, 12, 13]);
+        assert!(buf == vec!(10, 11, 12, 13));
     }
 
     #[test]
@@ -393,7 +393,7 @@ mod test {
             count: 0,
         };
         let buf = reader.read_to_end().unwrap();
-        assert!(buf == ~[10, 11]);
+        assert!(buf == vec!(10, 11));
     }
 
     #[test]
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 410b841545e..2fea002d419 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -1074,7 +1074,7 @@ mod test {
         check!(copy(&input, &output));
 
         assert_eq!(check!(File::open(&output).read_to_end()),
-                   (bytes!("foo")).to_owned());
+                   (Vec::from_slice(bytes!("foo"))));
     })
 
     iotest!(fn copy_file_src_dir() {
@@ -1114,7 +1114,7 @@ mod test {
         }
         assert_eq!(check!(stat(&out)).size, check!(stat(&input)).size);
         assert_eq!(check!(File::open(&out).read_to_end()),
-                   (bytes!("foobar")).to_owned());
+                   (Vec::from_slice(bytes!("foobar"))));
     })
 
     #[cfg(not(windows))] // apparently windows doesn't like symlinks
@@ -1146,7 +1146,7 @@ mod test {
         }
         assert_eq!(check!(stat(&out)).size, check!(stat(&input)).size);
         assert_eq!(check!(File::open(&out).read_to_end()),
-                   (bytes!("foobar")).to_owned());
+                   (Vec::from_slice(bytes!("foobar"))));
 
         // can't link to yourself
         match link(&input, &input) {
@@ -1206,7 +1206,7 @@ mod test {
         check!(file.fsync());
         assert_eq!(check!(stat(&path)).size, 10);
         assert_eq!(check!(File::open(&path).read_to_end()),
-                   (bytes!("foobar", 0, 0, 0, 0)).to_owned());
+                   (Vec::from_slice(bytes!("foobar", 0, 0, 0, 0))));
 
         // Truncate to a smaller length, don't seek, and then write something.
         // Ensure that the intermediate zeroes are all filled in (we're seeked
@@ -1217,7 +1217,7 @@ mod test {
         check!(file.fsync());
         assert_eq!(check!(stat(&path)).size, 9);
         assert_eq!(check!(File::open(&path).read_to_end()),
-                   (bytes!("fo", 0, 0, 0, 0, "wut")).to_owned());
+                   (Vec::from_slice(bytes!("fo", 0, 0, 0, 0, "wut"))));
         drop(file);
     })
 
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index e9c6b5b01da..1cf6ed9a5d9 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -18,6 +18,7 @@ use io;
 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
 use slice;
 use slice::{Vector, ImmutableVector, MutableVector, OwnedCloneableVector};
+use vec::Vec;
 
 fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
     // compute offset as signed and clamp to prevent overflow
@@ -49,10 +50,10 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64>
 /// let mut w = MemWriter::new();
 /// w.write([0, 1, 2]);
 ///
-/// assert_eq!(w.unwrap(), ~[0, 1, 2]);
+/// assert_eq!(w.unwrap(), vec!(0, 1, 2));
 /// ```
 pub struct MemWriter {
-    buf: ~[u8],
+    buf: Vec<u8>,
     pos: uint,
 }
 
@@ -64,7 +65,7 @@ impl MemWriter {
     /// Create a new `MemWriter`, allocating at least `n` bytes for
     /// the internal buffer.
     pub fn with_capacity(n: uint) -> MemWriter {
-        MemWriter { buf: slice::with_capacity(n), pos: 0 }
+        MemWriter { buf: Vec::with_capacity(n), pos: 0 }
     }
 
     /// Acquires an immutable reference to the underlying buffer of this
@@ -75,7 +76,7 @@ impl MemWriter {
     pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
 
     /// Unwraps this `MemWriter`, returning the underlying buffer
-    pub fn unwrap(self) -> ~[u8] { self.buf }
+    pub fn unwrap(self) -> Vec<u8> { self.buf }
 }
 
 impl Writer for MemWriter {
@@ -127,19 +128,19 @@ impl Seek for MemWriter {
 /// # #[allow(unused_must_use)];
 /// use std::io::MemReader;
 ///
-/// let mut r = MemReader::new(~[0, 1, 2]);
+/// let mut r = MemReader::new(vec!(0, 1, 2));
 ///
-/// assert_eq!(r.read_to_end().unwrap(), ~[0, 1, 2]);
+/// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2));
 /// ```
 pub struct MemReader {
-    buf: ~[u8],
+    buf: Vec<u8>,
     pos: uint
 }
 
 impl MemReader {
     /// Creates a new `MemReader` which will read the buffer given. The buffer
     /// can be re-acquired through `unwrap`
-    pub fn new(buf: ~[u8]) -> MemReader {
+    pub fn new(buf: Vec<u8>) -> MemReader {
         MemReader {
             buf: buf,
             pos: 0
@@ -159,7 +160,7 @@ impl MemReader {
     pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
 
     /// Unwraps this `MemReader`, returning the underlying buffer
-    pub fn unwrap(self) -> ~[u8] { self.buf }
+    pub fn unwrap(self) -> Vec<u8> { self.buf }
 }
 
 impl Reader for MemReader {
@@ -272,7 +273,7 @@ impl<'a> Seek for BufWriter<'a> {
 /// let mut buf = [0, 1, 2, 3];
 /// let mut r = BufReader::new(buf);
 ///
-/// assert_eq!(r.read_to_end().unwrap(), ~[0, 1, 2, 3]);
+/// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2, 3));
 /// ```
 pub struct BufReader<'a> {
     buf: &'a [u8],
@@ -425,7 +426,7 @@ mod test {
 
     #[test]
     fn test_mem_reader() {
-        let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]);
+        let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut buf = [];
         assert_eq!(reader.read(buf), Ok(0));
         assert_eq!(reader.tell(), Ok(0));
@@ -440,9 +441,9 @@ mod test {
         assert_eq!(reader.read(buf), Ok(3));
         assert_eq!(buf.slice(0, 3), &[5, 6, 7]);
         assert!(reader.read(buf).is_err());
-        let mut reader = MemReader::new(~[0, 1, 2, 3, 4, 5, 6, 7]);
-        assert_eq!(reader.read_until(3).unwrap(), ~[0, 1, 2, 3]);
-        assert_eq!(reader.read_until(3).unwrap(), ~[4, 5, 6, 7]);
+        let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
+        assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
+        assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
         assert!(reader.read(buf).is_err());
     }
 
@@ -465,8 +466,8 @@ mod test {
         assert_eq!(buf.slice(0, 3), &[5, 6, 7]);
         assert!(reader.read(buf).is_err());
         let mut reader = BufReader::new(in_buf);
-        assert_eq!(reader.read_until(3).unwrap(), ~[0, 1, 2, 3]);
-        assert_eq!(reader.read_until(3).unwrap(), ~[4, 5, 6, 7]);
+        assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
+        assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
         assert!(reader.read(buf).is_err());
     }
 
@@ -525,7 +526,7 @@ mod test {
         r.seek(10, SeekSet).unwrap();
         assert!(r.read(&mut []).is_err());
 
-        let mut r = MemReader::new(~[10]);
+        let mut r = MemReader::new(vec!(10));
         r.seek(10, SeekSet).unwrap();
         assert!(r.read(&mut []).is_err());
 
@@ -545,7 +546,7 @@ mod test {
         let mut r = BufReader::new(buf);
         assert!(r.seek(-1, SeekSet).is_err());
 
-        let mut r = MemReader::new(~[10]);
+        let mut r = MemReader::new(vec!(10));
         assert!(r.seek(-1, SeekSet).is_err());
 
         let mut r = MemWriter::new();
@@ -558,7 +559,7 @@ mod test {
 
     #[test]
     fn io_fill() {
-        let mut r = MemReader::new(~[1, 2, 3, 4, 5, 6, 7, 8]);
+        let mut r = MemReader::new(vec!(1, 2, 3, 4, 5, 6, 7, 8));
         let mut buf = [0, ..3];
         assert_eq!(r.fill(buf), Ok(()));
         assert_eq!(buf.as_slice(), &[1, 2, 3]);
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 403e0e48fd5..97519adbc3f 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -225,8 +225,8 @@ use str::{StrSlice, OwnedStr};
 use str;
 use uint;
 use unstable::finally::try_finally;
-use slice::{OwnedVector, MutableVector, ImmutableVector, OwnedCloneableVector};
-use slice;
+use slice::{Vector, OwnedVector, MutableVector, ImmutableVector, OwnedCloneableVector};
+use vec::Vec;
 
 // Reexports
 pub use self::stdio::stdin;
@@ -486,9 +486,9 @@ pub trait Reader {
     /// or EOF. If `Ok(())` is returned, then all of the requested bytes were
     /// pushed on to the vector, otherwise the amount `len` bytes couldn't be
     /// read (an error was encountered), and the error is returned.
-    fn push_exact(&mut self, buf: &mut ~[u8], len: uint) -> IoResult<()> {
+    fn push_exact(&mut self, buf: &mut Vec<u8>, len: uint) -> IoResult<()> {
         struct State<'a> {
-            buf: &'a mut ~[u8],
+            buf: &'a mut Vec<u8>,
             total_read: uint
         }
 
@@ -526,8 +526,8 @@ pub trait Reader {
     /// have already been consumed from the underlying reader, and they are lost
     /// (not returned as part of the error). If this is unacceptable, then it is
     /// recommended to use the `push_exact` or `read` methods.
-    fn read_exact(&mut self, len: uint) -> IoResult<~[u8]> {
-        let mut buf = slice::with_capacity(len);
+    fn read_exact(&mut self, len: uint) -> IoResult<Vec<u8>> {
+        let mut buf = Vec::with_capacity(len);
         match self.push_exact(&mut buf, len) {
             Ok(()) => Ok(buf),
             Err(e) => Err(e),
@@ -542,8 +542,8 @@ pub trait Reader {
     /// discarded when an error is returned.
     ///
     /// When EOF is encountered, all bytes read up to that point are returned.
-    fn read_to_end(&mut self) -> IoResult<~[u8]> {
-        let mut buf = slice::with_capacity(DEFAULT_BUF_SIZE);
+    fn read_to_end(&mut self) -> IoResult<Vec<u8>> {
+        let mut buf = Vec::with_capacity(DEFAULT_BUF_SIZE);
         loop {
             match self.push_exact(&mut buf, DEFAULT_BUF_SIZE) {
                 Ok(()) => {}
@@ -564,8 +564,8 @@ pub trait Reader {
     /// UTF-8 bytes.
     fn read_to_str(&mut self) -> IoResult<~str> {
         self.read_to_end().and_then(|s| {
-            match str::from_utf8_owned(s) {
-                Some(s) => Ok(s),
+            match str::from_utf8(s.as_slice()) {
+                Some(s) => Ok(s.to_owned()),
                 None => Err(standard_error(InvalidInput)),
             }
         })
@@ -1198,8 +1198,8 @@ pub trait Buffer: Reader {
     /// valid UTF-8 sequence of bytes.
     fn read_line(&mut self) -> IoResult<~str> {
         self.read_until('\n' as u8).and_then(|line|
-            match str::from_utf8_owned(line) {
-                Some(s) => Ok(s),
+            match str::from_utf8(line.as_slice()) {
+                Some(s) => Ok(s.to_owned()),
                 None => Err(standard_error(InvalidInput)),
             }
         )
@@ -1230,8 +1230,8 @@ pub trait Buffer: Reader {
     /// have been read, otherwise the pending byte buffer is returned. This
     /// is the reason that the byte buffer returned may not always contain the
     /// delimiter.
-    fn read_until(&mut self, byte: u8) -> IoResult<~[u8]> {
-        let mut res = ~[];
+    fn read_until(&mut self, byte: u8) -> IoResult<Vec<u8>> {
+        let mut res = Vec::new();
 
         let mut used;
         loop {
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index b4dcd204479..02c061c54dd 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -718,14 +718,14 @@ mod test {
         spawn(proc() {
             let mut a = a;
             let mut c = a.accept().unwrap();
-            assert_eq!(c.read_to_end(), Ok(~[]));
+            assert_eq!(c.read_to_end(), Ok(vec!()));
             c.write([1]).unwrap();
         });
 
         let mut s = TcpStream::connect(addr).unwrap();
         assert!(s.obj.close_write().is_ok());
         assert!(s.write([1]).is_err());
-        assert_eq!(s.read_to_end(), Ok(~[1]));
+        assert_eq!(s.read_to_end(), Ok(vec!(1)));
     })
 }
 
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index 1f067021825..f0b96e2e76c 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -142,9 +142,9 @@ pub struct ProcessOutput {
     /// The status (exit code) of the process.
     pub status: ProcessExit,
     /// The data that the process wrote to stdout.
-    pub output: ~[u8],
+    pub output: Vec<u8>,
     /// The data that the process wrote to stderr.
-    pub error: ~[u8],
+    pub error: Vec<u8>,
 }
 
 /// Describes what to do with a standard io stream for a child process.
@@ -277,8 +277,8 @@ impl Process {
     /// };
     ///
     /// println!("status: {}", output.status);
-    /// println!("stdout: {}", str::from_utf8_lossy(output.output));
-    /// println!("stderr: {}", str::from_utf8_lossy(output.error));
+    /// println!("stdout: {}", str::from_utf8_lossy(output.output.as_slice()));
+    /// println!("stderr: {}", str::from_utf8_lossy(output.error.as_slice()));
     /// ```
     pub fn output(prog: &str, args: &[~str]) -> IoResult<ProcessOutput> {
         Process::new(prog, args).map(|mut p| p.wait_with_output())
@@ -387,14 +387,14 @@ impl Process {
     /// The stdin handle to the child is closed before waiting.
     pub fn wait_with_output(&mut self) -> ProcessOutput {
         drop(self.stdin.take());
-        fn read(stream: Option<io::PipeStream>) -> Receiver<IoResult<~[u8]>> {
+        fn read(stream: Option<io::PipeStream>) -> Receiver<IoResult<Vec<u8>>> {
             let (tx, rx) = channel();
             match stream {
                 Some(stream) => spawn(proc() {
                     let mut stream = stream;
                     tx.send(stream.read_to_end())
                 }),
-                None => tx.send(Ok(~[]))
+                None => tx.send(Ok(Vec::new()))
             }
             rx
         }
@@ -404,8 +404,8 @@ impl Process {
         let status = self.wait();
 
         ProcessOutput { status: status,
-                        output: stdout.recv().ok().unwrap_or(~[]),
-                        error:  stderr.recv().ok().unwrap_or(~[]) }
+                        output: stdout.recv().ok().unwrap_or(Vec::new()),
+                        error:  stderr.recv().ok().unwrap_or(Vec::new()) }
     }
 }
 
@@ -614,13 +614,13 @@ mod tests {
 
         let ProcessOutput {status, output, error}
              = Process::output("echo", [~"hello"]).unwrap();
-        let output_str = str::from_utf8_owned(output).unwrap();
+        let output_str = str::from_utf8(output.as_slice()).unwrap();
 
         assert!(status.success());
         assert_eq!(output_str.trim().to_owned(), ~"hello");
         // FIXME #7224
         if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
+            assert_eq!(error, Vec::new());
         }
     })
 
@@ -630,7 +630,7 @@ mod tests {
              = Process::output("mkdir", [~"."]).unwrap();
 
         assert!(status.matches_exit_status(1));
-        assert_eq!(output, ~[]);
+        assert_eq!(output, Vec::new());
         assert!(!error.is_empty());
     })
 
@@ -652,13 +652,13 @@ mod tests {
 
         let mut prog = Process::new("echo", [~"hello"]).unwrap();
         let ProcessOutput {status, output, error} = prog.wait_with_output();
-        let output_str = str::from_utf8_owned(output).unwrap();
+        let output_str = str::from_utf8(output.as_slice()).unwrap();
 
         assert!(status.success());
         assert_eq!(output_str.trim().to_owned(), ~"hello");
         // FIXME #7224
         if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
+            assert_eq!(error, Vec::new());
         }
     })
 
@@ -667,22 +667,22 @@ mod tests {
         let mut prog = Process::new("echo", [~"hello"]).unwrap();
         let ProcessOutput {status, output, error} = prog.wait_with_output();
 
-        let output_str = str::from_utf8_owned(output).unwrap();
+        let output_str = str::from_utf8(output.as_slice()).unwrap();
 
         assert!(status.success());
         assert_eq!(output_str.trim().to_owned(), ~"hello");
         // FIXME #7224
         if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
+            assert_eq!(error, Vec::new());
         }
 
         let ProcessOutput {status, output, error} = prog.wait_with_output();
 
         assert!(status.success());
-        assert_eq!(output, ~[]);
+        assert_eq!(output, Vec::new());
         // FIXME #7224
         if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
+            assert_eq!(error, Vec::new());
         }
     })
 
@@ -718,7 +718,7 @@ mod tests {
         use os;
         let mut prog = run_pwd(None);
 
-        let output = str::from_utf8_owned(prog.wait_with_output().output).unwrap();
+        let output = str::from_utf8(prog.wait_with_output().output.as_slice()).unwrap().to_owned();
         let parent_dir = os::getcwd();
         let child_dir = Path::new(output.trim());
 
@@ -736,7 +736,7 @@ mod tests {
         let parent_dir = os::getcwd().dir_path();
         let mut prog = run_pwd(Some(&parent_dir));
 
-        let output = str::from_utf8_owned(prog.wait_with_output().output).unwrap();
+        let output = str::from_utf8(prog.wait_with_output().output.as_slice()).unwrap().to_owned();
         let child_dir = Path::new(output.trim());
 
         let parent_stat = parent_dir.stat().unwrap();
@@ -780,7 +780,7 @@ mod tests {
         if running_on_valgrind() { return; }
 
         let mut prog = run_env(None);
-        let output = str::from_utf8_owned(prog.wait_with_output().output).unwrap();
+        let output = str::from_utf8(prog.wait_with_output().output.as_slice()).unwrap().to_owned();
 
         let r = os::env();
         for &(ref k, ref v) in r.iter() {
@@ -794,7 +794,7 @@ mod tests {
         if running_on_valgrind() { return; }
 
         let mut prog = run_env(None);
-        let output = str::from_utf8_owned(prog.wait_with_output().output).unwrap();
+        let output = str::from_utf8(prog.wait_with_output().output.as_slice()).unwrap().to_owned();
 
         let r = os::env();
         for &(ref k, ref v) in r.iter() {
@@ -811,7 +811,7 @@ mod tests {
 
         let mut prog = run_env(Some(new_env));
         let result = prog.wait_with_output();
-        let output = str::from_utf8_lossy(result.output).into_owned();
+        let output = str::from_utf8_lossy(result.output.as_slice()).into_owned();
 
         assert!(output.contains("RUN_TEST_NEW_ENV=123"),
                 "didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs
index 7681e208bc4..a69f6c10abf 100644
--- a/src/libstd/io/result.rs
+++ b/src/libstd/io/result.rs
@@ -87,7 +87,7 @@ mod test {
         let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new());
         writer.write([0, 1, 2]).unwrap();
         writer.flush().unwrap();
-        assert_eq!(writer.unwrap().unwrap(), ~[0, 1, 2]);
+        assert_eq!(writer.unwrap().unwrap(), vec!(0, 1, 2));
     }
 
     #[test]
@@ -108,7 +108,7 @@ mod test {
     #[test]
     fn test_option_reader() {
         let mut reader: io::IoResult<MemReader> =
-            Ok(MemReader::new(~[0, 1, 2, 3]));
+            Ok(MemReader::new(vec!(0, 1, 2, 3)));
         let mut buf = [0, 0];
         reader.read(buf).unwrap();
         assert_eq!(buf.as_slice(), &[0, 1]);
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index a294ba17289..cbe157633b2 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -85,12 +85,12 @@ impl Reader for NullReader {
 
 /// A `Writer` which multiplexes writes to a set of `Writers`.
 pub struct MultiWriter {
-    writers: ~[~Writer]
+    writers: Vec<~Writer>
 }
 
 impl MultiWriter {
     /// Creates a new `MultiWriter`
-    pub fn new(writers: ~[~Writer]) -> MultiWriter {
+    pub fn new(writers: Vec<~Writer>) -> MultiWriter {
         MultiWriter { writers: writers }
     }
 }
@@ -204,31 +204,31 @@ mod test {
 
     #[test]
     fn test_limit_reader_unlimited() {
-        let mut r = MemReader::new(~[0, 1, 2]);
+        let mut r = MemReader::new(vec!(0, 1, 2));
         {
             let mut r = LimitReader::new(r.by_ref(), 4);
-            assert_eq!(~[0, 1, 2], r.read_to_end().unwrap());
+            assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
         }
     }
 
     #[test]
     fn test_limit_reader_limited() {
-        let mut r = MemReader::new(~[0, 1, 2]);
+        let mut r = MemReader::new(vec!(0, 1, 2));
         {
             let mut r = LimitReader::new(r.by_ref(), 2);
-            assert_eq!(~[0, 1], r.read_to_end().unwrap());
+            assert_eq!(vec!(0, 1), r.read_to_end().unwrap());
         }
-        assert_eq!(~[2], r.read_to_end().unwrap());
+        assert_eq!(vec!(2), r.read_to_end().unwrap());
     }
 
     #[test]
     fn test_limit_reader_limit() {
-        let r = MemReader::new(~[0, 1, 2]);
+        let r = MemReader::new(vec!(0, 1, 2));
         let mut r = LimitReader::new(r, 3);
         assert_eq!(3, r.limit());
         assert_eq!(0, r.read_byte().unwrap());
         assert_eq!(2, r.limit());
-        assert_eq!(~[1, 2], r.read_to_end().unwrap());
+        assert_eq!(vec!(1, 2), r.read_to_end().unwrap());
         assert_eq!(0, r.limit());
     }
 
@@ -273,8 +273,8 @@ mod test {
             }
         }
 
-        let mut multi = MultiWriter::new(~[~TestWriter as ~Writer,
-                                           ~TestWriter as ~Writer]);
+        let mut multi = MultiWriter::new(vec!(~TestWriter as ~Writer,
+                                              ~TestWriter as ~Writer));
         multi.write([1, 2, 3]).unwrap();
         assert_eq!(2, unsafe { writes });
         assert_eq!(0, unsafe { flushes });
@@ -285,26 +285,26 @@ mod test {
 
     #[test]
     fn test_chained_reader() {
-        let rs = ~[MemReader::new(~[0, 1]), MemReader::new(~[]),
-                   MemReader::new(~[2, 3])];
+        let rs = vec!(MemReader::new(vec!(0, 1)), MemReader::new(vec!()),
+                      MemReader::new(vec!(2, 3)));
         let mut r = ChainedReader::new(rs.move_iter());
-        assert_eq!(~[0, 1, 2, 3], r.read_to_end().unwrap());
+        assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap());
     }
 
     #[test]
     fn test_tee_reader() {
-        let mut r = TeeReader::new(MemReader::new(~[0, 1, 2]),
+        let mut r = TeeReader::new(MemReader::new(vec!(0, 1, 2)),
                                    MemWriter::new());
-        assert_eq!(~[0, 1, 2], r.read_to_end().unwrap());
+        assert_eq!(vec!(0, 1, 2), r.read_to_end().unwrap());
         let (_, w) = r.unwrap();
-        assert_eq!(~[0, 1, 2], w.unwrap());
+        assert_eq!(vec!(0, 1, 2), w.unwrap());
     }
 
     #[test]
     fn test_copy() {
-        let mut r = MemReader::new(~[0, 1, 2, 3, 4]);
+        let mut r = MemReader::new(vec!(0, 1, 2, 3, 4));
         let mut w = MemWriter::new();
         copy(&mut r, &mut w).unwrap();
-        assert_eq!(~[0, 1, 2, 3, 4], w.unwrap());
+        assert_eq!(vec!(0, 1, 2, 3, 4), w.unwrap());
     }
 }
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index a1fa7cb225f..e12e0234d96 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -28,7 +28,7 @@ use reflect::{MovePtr, align};
 use result::{Ok, Err};
 use str::StrSlice;
 use to_str::ToStr;
-use slice::OwnedVector;
+use slice::{Vector, OwnedVector};
 use intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc};
 use raw;
 
@@ -608,7 +608,7 @@ pub fn repr_to_str<T>(t: &T) -> ~str {
 
     let mut result = io::MemWriter::new();
     write_repr(&mut result as &mut io::Writer, t).unwrap();
-    str::from_utf8_owned(result.unwrap()).unwrap()
+    str::from_utf8(result.unwrap().as_slice()).unwrap().to_owned()
 }
 
 #[cfg(test)]
@@ -626,7 +626,7 @@ fn test_repr() {
     fn exact_test<T>(t: &T, e:&str) {
         let mut m = io::MemWriter::new();
         write_repr(&mut m as &mut io::Writer, t).unwrap();
-        let s = str::from_utf8_owned(m.unwrap()).unwrap();
+        let s = str::from_utf8(m.unwrap().as_slice()).unwrap().to_owned();
         assert_eq!(s.as_slice(), e);
     }
 
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 96f95622b92..bf8c15c20ab 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -756,7 +756,7 @@ mod test {
     macro_rules! t( ($a:expr, $b:expr) => ({
         let mut m = MemWriter::new();
         super::demangle(&mut m, $a).unwrap();
-        assert_eq!(str::from_utf8_owned(m.unwrap()).unwrap(), $b.to_owned());
+        assert_eq!(str::from_utf8(m.unwrap().as_slice()).unwrap().to_owned(), $b.to_owned());
     }) )
 
     #[test]