Fallout from renaming

24 files changed, 75 insertions, 69 deletions

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index f7b23163dfe..fd8432ded8b 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -464,7 +464,7 @@ impl<'a> AsciiExt<Vec<u8>> for &'a [u8] {
 impl OwnedAsciiExt for Vec<u8> {
     #[inline]
     fn into_ascii_upper(mut self) -> Vec<u8> {
-        for byte in self.mut_iter() {
+        for byte in self.iter_mut() {
             *byte = ASCII_UPPER_MAP[*byte as uint];
         }
         self
@@ -472,7 +472,7 @@ impl OwnedAsciiExt for Vec<u8> {
 
     #[inline]
     fn into_ascii_lower(mut self) -> Vec<u8> {
-        for byte in self.mut_iter() {
+        for byte in self.iter_mut() {
             *byte = ASCII_LOWER_MAP[*byte as uint];
         }
         self
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 5f52c0ada5d..d8a7305810f 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -73,7 +73,7 @@ impl<T> CVec<T> {
     /// * base - A raw pointer to a buffer
     /// * len - The number of elements in the buffer
     pub unsafe fn new(base: *mut T, len: uint) -> CVec<T> {
-        assert!(base != ptr::mut_null());
+        assert!(base != ptr::null_mut());
         CVec {
             base: base,
             len: len,
@@ -94,7 +94,7 @@ impl<T> CVec<T> {
     ///          for freeing the buffer, etc.
     pub unsafe fn new_with_dtor(base: *mut T, len: uint,
                                 dtor: proc():Send) -> CVec<T> {
-        assert!(base != ptr::mut_null());
+        assert!(base != ptr::null_mut());
         CVec {
             base: base,
             len: len,
@@ -191,7 +191,7 @@ mod tests {
     #[should_fail]
     fn test_fail_at_null() {
         unsafe {
-            CVec::new(ptr::mut_null::<u8>(), 9);
+            CVec::new(ptr::null_mut::<u8>(), 9);
         }
     }
 
diff --git a/src/libstd/collections/hashmap/map.rs b/src/libstd/collections/hashmap/map.rs
index 4a58f4e75de..e8c5eecc6f2 100644
--- a/src/libstd/collections/hashmap/map.rs
+++ b/src/libstd/collections/hashmap/map.rs
@@ -696,7 +696,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
 
         if new_capacity < old_table.capacity() {
             // Shrink the table. Naive algorithm for resizing:
-            for (h, k, v) in old_table.move_iter() {
+            for (h, k, v) in old_table.into_iter() {
                 self.insert_hashed_nocheck(h, k, v);
             }
         } else {
@@ -943,7 +943,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     ///
     /// let new = vec!["a key", "b key", "z key"];
     ///
-    /// for k in new.move_iter() {
+    /// for k in new.into_iter() {
     ///     map.find_with_or_insert_with(
     ///         k, "new value",
     ///         // if the key does exist either prepend or append this
@@ -1214,7 +1214,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// map.insert("c", 3);
     ///
     /// // Update all values
-    /// for (_, val) in map.mut_iter() {
+    /// for (_, val) in map.iter_mut() {
     ///     *val *= 2;
     /// }
     ///
@@ -1223,7 +1223,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// }
     /// ```
     pub fn iter_mut(&mut self) -> MutEntries<K, V> {
-        MutEntries { inner: self.table.mut_iter() }
+        MutEntries { inner: self.table.iter_mut() }
     }
 
     /// Deprecated: use `into_iter`.
@@ -1247,11 +1247,11 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// map.insert("c", 3);
     ///
     /// // Not possible with .iter()
-    /// let vec: Vec<(&str, int)> = map.move_iter().collect();
+    /// let vec: Vec<(&str, int)> = map.into_iter().collect();
     /// ```
     pub fn into_iter(self) -> MoveEntries<K, V> {
         MoveEntries {
-            inner: self.table.move_iter().map(|(_, k, v)| (k, v))
+            inner: self.table.into_iter().map(|(_, k, v)| (k, v))
         }
     }
 }
@@ -1573,7 +1573,7 @@ mod test_map {
         drop(hm.clone());
 
         {
-            let mut half = hm.move_iter().take(50);
+            let mut half = hm.into_iter().take(50);
 
             let v = drop_vector.get().unwrap();
             for i in range(0u, 200) {
@@ -1797,7 +1797,7 @@ mod test_map {
     #[test]
     fn test_keys() {
         let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<HashMap<int, char>>();
+        let map = vec.into_iter().collect::<HashMap<int, char>>();
         let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
         assert_eq!(keys.len(), 3);
         assert!(keys.contains(&1));
@@ -1808,7 +1808,7 @@ mod test_map {
     #[test]
     fn test_values() {
         let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
-        let map = vec.move_iter().collect::<HashMap<int, char>>();
+        let map = vec.into_iter().collect::<HashMap<int, char>>();
         let values = map.values().map(|&v| v).collect::<Vec<char>>();
         assert_eq!(values.len(), 3);
         assert!(values.contains(&'a'));
@@ -1997,7 +1997,7 @@ mod test_map {
 
         let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
 
-        let mut iter = map.mut_iter();
+        let mut iter = map.iter_mut();
 
         for _ in iter.by_ref().take(3) {}
 
diff --git a/src/libstd/collections/hashmap/set.rs b/src/libstd/collections/hashmap/set.rs
index 4a2a04cbc9f..dde1f27c9a3 100644
--- a/src/libstd/collections/hashmap/set.rs
+++ b/src/libstd/collections/hashmap/set.rs
@@ -245,6 +245,12 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
         self.map.keys()
     }
 
+    /// Deprecated: use `into_iter`.
+    #[deprecated = "use into_iter"]
+    pub fn move_iter(self) -> SetMoveItems<T> {
+        self.into_iter()
+    }
+
     /// Creates a consuming iterator, that is, one that moves each value out
     /// of the set in arbitrary order. The set cannot be used after calling
     /// this.
@@ -258,15 +264,15 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// set.insert("b".to_string());
     ///
     /// // Not possible to collect to a Vec<String> with a regular `.iter()`.
-    /// let v: Vec<String> = set.move_iter().collect();
+    /// let v: Vec<String> = set.into_iter().collect();
     ///
     /// // Will print in an arbitrary order.
     /// for x in v.iter() {
     ///     println!("{}", x);
     /// }
     /// ```
-    pub fn move_iter(self) -> SetMoveItems<T> {
-        self.map.move_iter().map(|(k, _)| k)
+    pub fn into_iter(self) -> SetMoveItems<T> {
+        self.map.into_iter().map(|(k, _)| k)
     }
 
     /// Visit the values representing the difference.
@@ -661,7 +667,7 @@ mod test_set {
             hs
         };
 
-        let v = hs.move_iter().collect::<Vec<char>>();
+        let v = hs.into_iter().collect::<Vec<char>>();
         assert!(['a', 'b'] == v.as_slice() || ['b', 'a'] == v.as_slice());
     }
 
diff --git a/src/libstd/collections/hashmap/table.rs b/src/libstd/collections/hashmap/table.rs
index 33e760f11ce..87a5cc1484a 100644
--- a/src/libstd/collections/hashmap/table.rs
+++ b/src/libstd/collections/hashmap/table.rs
@@ -872,7 +872,7 @@ impl<K, V> Drop for RawTable<K, V> {
             return;
         }
         // This is done in reverse because we've likely partially taken
-        // some elements out with `.move_iter()` from the front.
+        // some elements out with `.into_iter()` from the front.
         // Check if the size is 0, so we don't do a useless scan when
         // dropping empty tables such as on resize.
         // Also avoid double drop of elements that have been already moved out.
diff --git a/src/libstd/collections/lru_cache.rs b/src/libstd/collections/lru_cache.rs
index 32a16053fff..5408e50f2bd 100644
--- a/src/libstd/collections/lru_cache.rs
+++ b/src/libstd/collections/lru_cache.rs
@@ -84,8 +84,8 @@ impl<K, V> LruEntry<K, V> {
         LruEntry {
             key: k,
             value: v,
-            next: ptr::mut_null(),
-            prev: ptr::mut_null(),
+            next: ptr::null_mut(),
+            prev: ptr::null_mut(),
         }
     }
 }
diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs
index eee3e81f5fc..e929f140dbd 100644
--- a/src/libstd/dynamic_lib.rs
+++ b/src/libstd/dynamic_lib.rs
@@ -301,7 +301,7 @@ pub mod dl {
     }
 
     pub unsafe fn open_internal() -> *mut u8 {
-        let mut handle = ptr::mut_null();
+        let mut handle = ptr::null_mut();
         GetModuleHandleExW(0 as libc::DWORD, ptr::null(), &mut handle);
         handle as *mut u8
     }
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());
     }
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index ea278d55db9..f1480eb7d45 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -218,7 +218,7 @@ fn with_env_lock<T>(f: || -> T) -> T {
 /// }
 /// ```
 pub fn env() -> Vec<(String,String)> {
-    env_as_bytes().move_iter().map(|(k,v)| {
+    env_as_bytes().into_iter().map(|(k,v)| {
         let k = String::from_utf8_lossy(k.as_slice()).into_string();
         let v = String::from_utf8_lossy(v.as_slice()).into_string();
         (k,v)
@@ -663,14 +663,14 @@ pub fn self_exe_name() -> Option<Path> {
                                -1 as c_int];
             let mut sz: libc::size_t = 0;
             let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
-                             ptr::mut_null(), &mut sz, ptr::mut_null(),
+                             ptr::null_mut(), &mut sz, ptr::null_mut(),
                              0u as libc::size_t);
             if err != 0 { return None; }
             if sz == 0 { return None; }
             let mut v: Vec<u8> = Vec::with_capacity(sz as uint);
             let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
                              v.as_mut_ptr() as *mut c_void, &mut sz,
-                             ptr::mut_null(), 0u as libc::size_t);
+                             ptr::null_mut(), 0u as libc::size_t);
             if err != 0 { return None; }
             if sz == 0 { return None; }
             v.set_len(sz as uint - 1); // chop off trailing NUL
@@ -695,7 +695,7 @@ pub fn self_exe_name() -> Option<Path> {
         unsafe {
             use libc::funcs::extra::_NSGetExecutablePath;
             let mut sz: u32 = 0;
-            _NSGetExecutablePath(ptr::mut_null(), &mut sz);
+            _NSGetExecutablePath(ptr::null_mut(), &mut sz);
             if sz == 0 { return None; }
             let mut v: Vec<u8> = Vec::with_capacity(sz as uint);
             let err = _NSGetExecutablePath(v.as_mut_ptr() as *mut i8, &mut sz);
@@ -1045,7 +1045,7 @@ pub fn error_string(errnum: uint) -> String {
         unsafe {
             let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
                                      FORMAT_MESSAGE_IGNORE_INSERTS,
-                                     ptr::mut_null(),
+                                     ptr::null_mut(),
                                      errnum as DWORD,
                                      langId,
                                      buf.as_mut_ptr(),
@@ -1192,7 +1192,7 @@ fn real_args_as_bytes() -> Vec<Vec<u8>> {
 
 #[cfg(not(windows))]
 fn real_args() -> Vec<String> {
-    real_args_as_bytes().move_iter()
+    real_args_as_bytes().into_iter()
                         .map(|v| {
                             String::from_utf8_lossy(v.as_slice()).into_string()
                         }).collect()
@@ -1229,7 +1229,7 @@ fn real_args() -> Vec<String> {
 
 #[cfg(windows)]
 fn real_args_as_bytes() -> Vec<Vec<u8>> {
-    real_args().move_iter().map(|s| s.into_bytes()).collect()
+    real_args().into_iter().map(|s| s.into_bytes()).collect()
 }
 
 type LPCWSTR = *const u16;
@@ -1529,7 +1529,7 @@ impl MemoryMap {
     pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> {
         use libc::types::os::arch::extra::{LPVOID, DWORD, SIZE_T, HANDLE};
 
-        let mut lpAddress: LPVOID = ptr::mut_null();
+        let mut lpAddress: LPVOID = ptr::null_mut();
         let mut readable = false;
         let mut writable = false;
         let mut executable = false;
@@ -1589,12 +1589,12 @@ impl MemoryMap {
             unsafe {
                 let hFile = libc::get_osfhandle(fd) as HANDLE;
                 let mapping = libc::CreateFileMappingW(hFile,
-                                                       ptr::mut_null(),
+                                                       ptr::null_mut(),
                                                        flProtect,
                                                        0,
                                                        0,
                                                        ptr::null());
-                if mapping == ptr::mut_null() {
+                if mapping == ptr::null_mut() {
                     return Err(ErrCreateFileMappingW(errno()));
                 }
                 if errno() as c_int == libc::ERROR_ALREADY_EXISTS {
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 06eab31d7bf..c654d3a668a 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -382,7 +382,7 @@ impl Path {
                         let n = if is_abs { comps.len() } else { comps.len() - 1} +
                                 comps.iter().map(|v| v.len()).sum();
                         let mut v = Vec::with_capacity(n);
-                        let mut it = comps.move_iter();
+                        let mut it = comps.into_iter();
                         if !is_abs {
                             match it.next() {
                                 None => (),
@@ -1201,7 +1201,7 @@ mod tests {
                     assert!(comps == exps, "components: Expected {:?}, found {:?}",
                             comps, exps);
                     let comps = path.components().rev().collect::<Vec<&[u8]>>();
-                    let exps = exps.move_iter().rev().collect::<Vec<&[u8]>>();
+                    let exps = exps.into_iter().rev().collect::<Vec<&[u8]>>();
                     assert!(comps == exps, "rev_components: Expected {:?}, found {:?}",
                             comps, exps);
                 }
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index d9864cfaa61..e68c8bdb07d 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -832,7 +832,7 @@ impl Path {
                             Some(_) => s.push_str(prefix_),
                             None => ()
                         }
-                        let mut it = comps.move_iter();
+                        let mut it = comps.into_iter();
                         if !is_abs {
                             match it.next() {
                                 None => (),
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index b9b7a02b62f..4b3ddc2f953 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -162,7 +162,7 @@
 //! // where the car is. The game host will never open the door with the car.
 //! fn game_host_open<R: Rng>(car: uint, choice: uint, rng: &mut R) -> uint {
 //!     let choices = free_doors(&[car, choice]);
-//!     rand::sample(rng, choices.move_iter(), 1)[0]
+//!     rand::sample(rng, choices.into_iter(), 1)[0]
 //! }
 //!
 //! // Returns the door we switch to, given our current choice and
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index c28b6c144a2..5557ef9943b 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -485,7 +485,7 @@ mod imp {
                     let bytes = path.as_vec();
                     if bytes.len() < LAST_FILENAME.len() {
                         let i = bytes.iter();
-                        for (slot, val) in LAST_FILENAME.mut_iter().zip(i) {
+                        for (slot, val) in LAST_FILENAME.iter_mut().zip(i) {
                             *slot = *val as libc::c_char;
                         }
                         LAST_FILENAME.as_ptr()
@@ -496,7 +496,7 @@ mod imp {
                 None => ptr::null(),
             };
             STATE = backtrace_create_state(filename, 0, error_cb,
-                                           ptr::mut_null());
+                                           ptr::null_mut());
             return STATE
         }
 
diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs
index da0c3daefe7..23ba582ec0a 100644
--- a/src/libstd/sync/task_pool.rs
+++ b/src/libstd/sync/task_pool.rs
@@ -31,7 +31,7 @@ pub struct TaskPool<T> {
 #[unsafe_destructor]
 impl<T> Drop for TaskPool<T> {
     fn drop(&mut self) {
-        for channel in self.channels.mut_iter() {
+        for channel in self.channels.iter_mut() {
             channel.send(Quit);
         }
     }