Fallout from renaming

11 files changed, 29 insertions, 29 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 76f86d66ff5..a777a372ad1 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -195,7 +195,7 @@ impl<W: Writer> Writer for BufferedWriter<W> {
         if buf.len() > self.buf.len() {
             self.inner.get_mut_ref().write(buf)
         } else {
-            let dst = self.buf.mut_slice_from(self.pos);
+            let dst = self.buf.slice_from_mut(self.pos);
             slice::bytes::copy_memory(dst, buf);
             self.pos += buf.len();
             Ok(())
@@ -273,7 +273,7 @@ impl<W> InternalBufferedWriter<W> {
 
 impl<W: Reader> Reader for InternalBufferedWriter<W> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
-        self.get_mut_ref().inner.get_mut_ref().read(buf)
+        self.get_mut().inner.get_mut_ref().read(buf)
     }
 }
 
@@ -359,10 +359,10 @@ impl<S: Stream> Reader for BufferedStream<S> {
 
 impl<S: Stream> Writer for BufferedStream<S> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
-        self.inner.inner.get_mut_ref().write(buf)
+        self.inner.inner.get_mut().write(buf)
     }
     fn flush(&mut self) -> IoResult<()> {
-        self.inner.inner.get_mut_ref().flush()
+        self.inner.inner.get_mut().flush()
     }
 }
 
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index 1c8b047f56f..f2ff5c7b5c2 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -62,7 +62,7 @@ impl Reader for ChanReader {
         loop {
             match self.buf {
                 Some(ref prev) => {
-                    let dst = buf.mut_slice_from(num_read);
+                    let dst = buf.slice_from_mut(num_read);
                     let src = prev.slice_from(self.pos);
                     let count = cmp::min(dst.len(), src.len());
                     bytes::copy_memory(dst, src.slice_to(count));
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index b7b7d1fb93d..f912b3ee38f 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -652,7 +652,7 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
 /// at a non-directory file
 pub fn readdir(path: &Path) -> IoResult<Vec<Path>> {
     let err = LocalIo::maybe_raise(|io| {
-        Ok(try!(io.fs_readdir(&path.to_c_str(), 0)).move_iter().map(|a| {
+        Ok(try!(io.fs_readdir(&path.to_c_str(), 0)).into_iter().map(|a| {
             Path::new(a)
         }).collect())
     }).map_err(IoError::from_rtio_error);
@@ -764,7 +764,7 @@ pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
 
         // delete all regular files in the way and push subdirs
         // on the stack
-        for child in children.move_iter() {
+        for child in children.into_iter() {
             // FIXME(#12795) we should use lstat in all cases
             let child_type = match cfg!(windows) {
                 true => try!(update_err(stat(&child), path)),
@@ -1059,11 +1059,11 @@ mod test {
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
             {
-                let read_buf = read_mem.mut_slice(0, 4);
+                let read_buf = read_mem.slice_mut(0, 4);
                 check!(read_stream.read(read_buf));
             }
             {
-                let read_buf = read_mem.mut_slice(4, 8);
+                let read_buf = read_mem.slice_mut(4, 8);
                 check!(read_stream.read(read_buf));
             }
         }
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 21ab9c1fdd4..c826bd16715 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -147,7 +147,7 @@ impl Reader for MemReader {
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
             let input = self.buf.slice(self.pos, self.pos + write_len);
-            let output = buf.mut_slice(0, write_len);
+            let output = buf.slice_mut(0, write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
         }
@@ -232,7 +232,7 @@ impl<'a> Writer for BufWriter<'a> {
             })
         }
 
-        slice::bytes::copy_memory(self.buf.mut_slice_from(self.pos), buf);
+        slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), buf);
         self.pos += buf.len();
         Ok(())
     }
@@ -293,7 +293,7 @@ impl<'a> Reader for BufReader<'a> {
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
             let input = self.buf.slice(self.pos, self.pos + write_len);
-            let output = buf.mut_slice(0, write_len);
+            let output = buf.slice_mut(0, write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
         }
@@ -548,7 +548,7 @@ mod test {
         assert!(r.read_at_least(buf.len(), buf).is_ok());
         let b: &[_] = &[1, 2, 3];
         assert_eq!(buf.as_slice(), b);
-        assert!(r.read_at_least(0, buf.mut_slice_to(0)).is_ok());
+        assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
         assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(buf.len(), buf).is_ok());
         let b: &[_] = &[4, 5, 6];
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 7a2bcab8706..ff508c802d8 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -578,7 +578,7 @@ pub trait Reader {
         while read < min {
             let mut zeroes = 0;
             loop {
-                match self.read(buf.mut_slice_from(read)) {
+                match self.read(buf.slice_from_mut(read)) {
                     Ok(0) => {
                         zeroes += 1;
                         if zeroes >= NO_PROGRESS_LIMIT {
@@ -1524,7 +1524,7 @@ pub trait Buffer: Reader {
         {
             let mut start = 1;
             while start < width {
-                match try!(self.read(buf.mut_slice(start, width))) {
+                match try!(self.read(buf.slice_mut(start, width))) {
                     n if n == width - start => break,
                     n if n < width - start => { start += n; }
                     _ => return Err(standard_error(InvalidInput)),
diff --git a/src/libstd/io/net/addrinfo.rs b/src/libstd/io/net/addrinfo.rs
index 771eb9e13e8..867e8bcca82 100644
--- a/src/libstd/io/net/addrinfo.rs
+++ b/src/libstd/io/net/addrinfo.rs
@@ -76,7 +76,7 @@ pub struct Info {
 /// Easy name resolution. Given a hostname, returns the list of IP addresses for
 /// that hostname.
 pub fn get_host_addresses(host: &str) -> IoResult<Vec<IpAddr>> {
-    lookup(Some(host), None, None).map(|a| a.move_iter().map(|i| i.address.ip).collect())
+    lookup(Some(host), None, None).map(|a| a.into_iter().map(|i| i.address.ip).collect())
 }
 
 /// Full-fledged resolution. This function will perform a synchronous call to
@@ -105,7 +105,7 @@ fn lookup(hostname: Option<&str>, servname: Option<&str>, hint: Option<Hint>)
     match LocalIo::maybe_raise(|io| {
         io.get_host_addresses(hostname, servname, hint)
     }) {
-        Ok(v) => Ok(v.move_iter().map(|info| {
+        Ok(v) => Ok(v.into_iter().map(|info| {
             Info {
                 address: SocketAddr {
                     ip: super::from_rtio(info.address.ip),
diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index ed76cdc276b..1141cd22eeb 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -109,7 +109,7 @@ impl<'a> Parser<'a> {
     // Return result of first successful parser
     fn read_or<T>(&mut self, parsers: &mut [|&mut Parser| -> Option<T>])
                -> Option<T> {
-        for pf in parsers.mut_iter() {
+        for pf in parsers.iter_mut() {
             match self.read_atomically(|p: &mut Parser| (*pf)(p)) {
                 Some(r) => return Some(r),
                 None => {}
@@ -233,7 +233,7 @@ impl<'a> Parser<'a> {
             assert!(head.len() + tail.len() <= 8);
             let mut gs = [0u16, ..8];
             gs.copy_from(head);
-            gs.mut_slice(8 - tail.len(), 8).copy_from(tail);
+            gs.slice_mut(8 - tail.len(), 8).copy_from(tail);
             Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
         }
 
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 5f7563e7467..6689615f01b 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -48,7 +48,7 @@ use rt::rtio;
 /// match socket.recv_from(buf) {
 ///     Ok((amt, src)) => {
 ///         // Send a reply to the socket we received data from
-///         let buf = buf.mut_slice_to(amt);
+///         let buf = buf.slice_to_mut(amt);
 ///         buf.reverse();
 ///         socket.send_to(buf, src);
 ///     }
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index c1f4161fe18..1225dcf1f4a 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -167,7 +167,7 @@ impl Command {
             None => {
                 // if the env is currently just inheriting from the parent's,
                 // materialize the parent's env into a hashtable.
-                self.env = Some(os::env_as_bytes().move_iter()
+                self.env = Some(os::env_as_bytes().into_iter()
                                    .map(|(k, v)| (k.as_slice().to_c_str(),
                                                   v.as_slice().to_c_str()))
                                    .collect());
@@ -289,7 +289,7 @@ impl Command {
                 detach: self.detach,
             };
             io.spawn(cfg).map(|(p, io)| {
-                let mut io = io.move_iter().map(|p| {
+                let mut io = io.into_iter().map(|p| {
                     p.map(|p| io::PipeStream::new(p))
                 });
                 Process {
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index 769ad2a8468..78d1a2f485a 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -166,7 +166,7 @@ mod darwin_fd_limit {
     pub unsafe fn raise_fd_limit() {
         // The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc
         // sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value.
-        use ptr::mut_null;
+        use ptr::null_mut;
         use mem::size_of_val;
         use os::last_os_error;
 
@@ -175,7 +175,7 @@ mod darwin_fd_limit {
         let mut maxfiles: libc::c_int = 0;
         let mut size: libc::size_t = size_of_val(&maxfiles) as libc::size_t;
         if sysctl(&mut mib[0], 2, &mut maxfiles as *mut libc::c_int as *mut libc::c_void, &mut size,
-                  mut_null(), 0) != 0 {
+                  null_mut(), 0) != 0 {
             let err = last_os_error();
             fail!("raise_fd_limit: error calling sysctl: {}", err);
         }
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 7fba0bc85a6..16ac8c4c265 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -47,7 +47,7 @@ impl<R: Reader> Reader for LimitReader<R> {
         }
 
         let len = cmp::min(self.limit, buf.len());
-        let res = self.inner.read(buf.mut_slice_to(len));
+        let res = self.inner.read(buf.slice_to_mut(len));
         match res {
             Ok(len) => self.limit -= len,
             _ => {}
@@ -139,7 +139,7 @@ impl MultiWriter {
 impl Writer for MultiWriter {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::IoResult<()> {
-        for writer in self.writers.mut_iter() {
+        for writer in self.writers.iter_mut() {
             try!(writer.write(buf));
         }
         Ok(())
@@ -147,7 +147,7 @@ impl Writer for MultiWriter {
 
     #[inline]
     fn flush(&mut self) -> io::IoResult<()> {
-        for writer in self.writers.mut_iter() {
+        for writer in self.writers.iter_mut() {
             try!(writer.flush());
         }
         Ok(())
@@ -251,7 +251,7 @@ impl<T: Iterator<u8>> Reader for IterReader<T> {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         let mut len = 0;
-        for (slot, elt) in buf.mut_iter().zip(self.iter.by_ref()) {
+        for (slot, elt) in buf.iter_mut().zip(self.iter.by_ref()) {
             *slot = elt;
             len += 1;
         }
@@ -364,7 +364,7 @@ mod test {
     fn test_chained_reader() {
         let rs = vec!(MemReader::new(vec!(0, 1)), MemReader::new(vec!()),
                       MemReader::new(vec!(2, 3)));
-        let mut r = ChainedReader::new(rs.move_iter());
+        let mut r = ChainedReader::new(rs.into_iter());
         assert_eq!(vec!(0, 1, 2, 3), r.read_to_end().unwrap());
     }