---

yaml
---
r: 178806
b: refs/heads/tmp
c: 9a17f62
h: refs/heads/master
v: v3

Author: dotdash

[refs]

@@ -34,4 +34,4 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 61b2f3a4f0a27180a0cdc3b3343ac63cf86ff8cc
+refs/heads/tmp: 9a17f62947d0c079f1c877de4fe1dab5b2c500d9

branches/tmp/src/libcollections/vec_map.rs

@@ -13,8 +13,6 @@
 
 #![allow(missing_docs)]
 
-pub use self::Entry::*;
-
 use core::prelude::*;
 
 use core::cmp::Ordering;
@@ -68,32 +66,6 @@ pub struct VecMap<V> {
     v: Vec<Option<V>>,
 }
 
-/// A view into a single entry in a map, which may either be vacant or occupied.
-#[unstable(feature = "collections",
-           reason = "precise API still under development")]
-pub enum Entry<'a, V:'a> {
-    /// A vacant Entry
-    Vacant(VacantEntry<'a, V>),
-    /// An occupied Entry
-    Occupied(OccupiedEntry<'a, V>),
-}
-
-/// A vacant Entry.
-#[unstable(feature = "collections",
-           reason = "precise API still under development")]
-pub struct VacantEntry<'a, V:'a> {
-    map: &'a mut VecMap<V>,
-    index: usize,
-}
-
-/// An occupied Entry.
-#[unstable(feature = "collections",
-           reason = "precise API still under development")]
-pub struct OccupiedEntry<'a, V:'a> {
-    map: &'a mut VecMap<V>,
-    index: usize,
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<V> Default for VecMap<V> {
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -513,119 +485,6 @@ impl<V> VecMap<V> {
         let result = &mut self.v[*key];
         result.take()
     }
-
-    /// Gets the given key's corresponding entry in the map for in-place manipulation.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecMap;
-    /// use std::collections::vec_map::Entry;
-    ///
-    /// let mut count: VecMap<u32> = VecMap::new();
-    ///
-    /// // count the number of occurrences of numbers in the vec
-    /// for x in vec![1, 2, 1, 2, 3, 4, 1, 2, 4].iter() {
-    ///     match count.entry(*x) {
-    ///         Entry::Vacant(view) => {
-    ///             view.insert(1);
-    ///         },
-    ///         Entry::Occupied(mut view) => {
-    ///             let v = view.get_mut();
-    ///             *v += 1;
-    ///         },
-    ///     }
-    /// }
-    ///
-    /// assert_eq!(count[1], 3);
-    /// ```
-    #[unstable(feature = "collections",
-               reason = "precise API still under development")]
-    pub fn entry(&mut self, key: usize) -> Entry<V> {
-        // FIXME(Gankro): this is basically the dumbest implementation of
-        // entry possible, because weird non-lexical borrows issues make it
-        // completely insane to do any other way. That said, Entry is a border-line
-        // useless construct on VecMap, so it's hardly a big loss.
-        if self.contains_key(&key) {
-            Occupied(OccupiedEntry {
-                map: self,
-                index: key,
-            })
-        } else {
-            Vacant(VacantEntry {
-                map: self,
-                index: key,
-            })
-        }
-    }
-}
-
-
-impl<'a, V> Entry<'a, V> {
-    #[unstable(feature = "collections",
-               reason = "matches collection reform v2 specification, waiting for dust to settle")]
-    /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
-    pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, V>> {
-        match self {
-            Occupied(entry) => Ok(entry.into_mut()),
-            Vacant(entry) => Err(entry),
-        }
-    }
-}
-
-impl<'a, V> VacantEntry<'a, V> {
-    /// Sets the value of the entry with the VacantEntry's key,
-    /// and returns a mutable reference to it.
-    #[unstable(feature = "collections",
-               reason = "matches collection reform v2 specification, waiting for dust to settle")]
-    pub fn insert(self, value: V) -> &'a mut V {
-        let index = self.index;
-        self.map.insert(index, value);
-        &mut self.map[index]
-    }
-}
-
-impl<'a, V> OccupiedEntry<'a, V> {
-    /// Gets a reference to the value in the entry.
-    #[unstable(feature = "collections",
-               reason = "matches collection reform v2 specification, waiting for dust to settle")]
-    pub fn get(&self) -> &V {
-        let index = self.index;
-        &self.map[index]
-    }
-
-    /// Gets a mutable reference to the value in the entry.
-    #[unstable(feature = "collections",
-               reason = "matches collection reform v2 specification, waiting for dust to settle")]
-    pub fn get_mut(&mut self) -> &mut V {
-        let index = self.index;
-        &mut self.map[index]
-    }
-
-    /// Converts the entry into a mutable reference to its value.
-    #[unstable(feature = "collections",
-               reason = "matches collection reform v2 specification, waiting for dust to settle")]
-    pub fn into_mut(self) -> &'a mut V {
-        let index = self.index;
-        &mut self.map[index]
-    }
-
-    /// Sets the value of the entry with the OccupiedEntry's key,
-    /// and returns the entry's old value.
-    #[unstable(feature = "collections",
-               reason = "matches collection reform v2 specification, waiting for dust to settle")]
-    pub fn insert(&mut self, value: V) -> V {
-        let index = self.index;
-        self.map.insert(index, value).unwrap()
-    }
-
-    /// Takes the value of the entry out of the map, and returns it.
-    #[unstable(feature = "collections",
-               reason = "matches collection reform v2 specification, waiting for dust to settle")]
-    pub fn remove(self) -> V {
-        let index = self.index;
-        self.map.remove(&index).unwrap()
-    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -924,7 +783,7 @@ mod test_map {
     use prelude::*;
     use core::hash::{hash, SipHasher};
 
-    use super::{VecMap, Occupied, Vacant};
+    use super::VecMap;
 
     #[test]
     fn test_get_mut() {
@@ -1276,57 +1135,6 @@ mod test_map {
 
         map[4];
     }
-
-    #[test]
-    fn test_entry(){
-        let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
-
-        let mut map: VecMap<i32> = xs.iter().map(|&x| x).collect();
-
-        // Existing key (insert)
-        match map.entry(1) {
-            Vacant(_) => unreachable!(),
-            Occupied(mut view) => {
-                assert_eq!(view.get(), &10);
-                assert_eq!(view.insert(100), 10);
-            }
-        }
-        assert_eq!(map.get(&1).unwrap(), &100);
-        assert_eq!(map.len(), 6);
-
-
-        // Existing key (update)
-        match map.entry(2) {
-            Vacant(_) => unreachable!(),
-            Occupied(mut view) => {
-                let v = view.get_mut();
-                *v *= 10;
-            }
-        }
-        assert_eq!(map.get(&2).unwrap(), &200);
-        assert_eq!(map.len(), 6);
-
-        // Existing key (take)
-        match map.entry(3) {
-            Vacant(_) => unreachable!(),
-            Occupied(view) => {
-                assert_eq!(view.remove(), 30);
-            }
-        }
-        assert_eq!(map.get(&3), None);
-        assert_eq!(map.len(), 5);
-
-
-        // Inexistent key (insert)
-        match map.entry(10) {
-            Occupied(_) => unreachable!(),
-            Vacant(view) => {
-                assert_eq!(*view.insert(1000), 1000);
-            }
-        }
-        assert_eq!(map.get(&10).unwrap(), &1000);
-        assert_eq!(map.len(), 6);
-    }
 }
 
 #[cfg(test)]

branches/tmp/src/libcore/error.rs

@@ -51,7 +51,7 @@
 //! use std::error::FromError;
 //! use std::old_io::{File, IoError};
 //! use std::os::{MemoryMap, MapError};
-//! use std::old_path::Path;
+//! use std::path::Path;
 //!
 //! enum MyError {
 //!     Io(IoError),

branches/tmp/src/libcore/fmt/mod.rs

@@ -264,7 +264,6 @@ pub trait Show {
 #[lang = "debug_trait"]
 pub trait Debug {
     /// Formats the value using the given formatter.
-    #[stable(feature = "rust1", since = "1.0.0")]
     fn fmt(&self, &mut Formatter) -> Result;
 }
 
@@ -291,7 +290,6 @@ pub trait String {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Display {
     /// Formats the value using the given formatter.
-    #[stable(feature = "rust1", since = "1.0.0")]
     fn fmt(&self, &mut Formatter) -> Result;
 }
 

branches/tmp/src/libcore/iter.rs

@@ -119,7 +119,6 @@ impl<'a, T> Iterator for &'a mut (Iterator<Item=T> + 'a) {
                           built from an iterator over elements of type `{A}`"]
 pub trait FromIterator<A> {
     /// Build a container with elements from an external iterator.
-    #[stable(feature = "rust1", since = "1.0.0")]
     fn from_iter<T: Iterator<Item=A>>(iterator: T) -> Self;
 }
 
@@ -724,11 +723,12 @@ pub trait IteratorExt: Iterator + Sized {
         P: FnMut(Self::Item) -> bool,
         Self: ExactSizeIterator + DoubleEndedIterator
     {
-        let len = self.len();
-        for i in (0..len).rev() {
-            if predicate(self.next_back().expect("rposition: incorrect ExactSizeIterator")) {
+        let mut i = self.len() - 1;
+        while let Some(v) = self.next_back() {
+            if predicate(v) {
                 return Some(i);
             }
+            i -= 1;
         }
         None
     }
@@ -1822,7 +1822,6 @@ impl<I: Iterator> Peekable<I> {
     /// Return a reference to the next element of the iterator with out
     /// advancing it, or None if the iterator is exhausted.
     #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
     pub fn peek(&mut self) -> Option<&I::Item> {
         if self.peeked.is_none() {
             self.peeked = self.iter.next();

branches/tmp/src/libgraphviz/maybe_owned_vec.rs

@@ -17,7 +17,7 @@ use std::cmp::Ordering;
 use std::default::Default;
 use std::fmt;
 use std::iter::FromIterator;
-use std::old_path::BytesContainer;
+use std::path::BytesContainer;
 use std::slice;
 
 // Note 1: It is not clear whether the flexibility of providing both

branches/tmp/src/librustc_back/target/mod.rs

@@ -306,7 +306,7 @@ impl Target {
         use std::env;
         use std::ffi::OsString;
         use std::old_io::File;
-        use std::old_path::Path;
+        use std::path::Path;
         use serialize::json;
 
         fn load_file(path: &Path) -> Result<Target, String> {

branches/tmp/src/librustc_trans/trans/debuginfo.rs

@@ -1590,7 +1590,7 @@ fn compile_unit_metadata(cx: &CrateContext) -> DIDescriptor {
                     Some(ref p) if p.is_relative() => {
                         // prepend "./" if necessary
                         let dotdot = b"..";
-                        let prefix: &[u8] = &[dotdot[0], ::std::old_path::SEP_BYTE];
+                        let prefix: &[u8] = &[dotdot[0], ::std::path::SEP_BYTE];
                         let mut path_bytes = p.as_vec().to_vec();
 
                         if &path_bytes[..2] != prefix &&

branches/tmp/src/librustc_trans/trans/expr.rs

@@ -194,8 +194,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 // a different region or mutability, but we don't care here. It might
                 // also be just in case we need to unsize. But if there are no nested
                 // adjustments then it should be a no-op).
-                Some(ty::AutoPtr(_, _, None)) |
-                Some(ty::AutoUnsafe(_, None)) if adj.autoderefs == 1 => {
+                Some(ty::AutoPtr(_, _, None)) if adj.autoderefs == 1 => {
                     match datum.ty.sty {
                         // Don't skip a conversion from Box<T> to &T, etc.
                         ty::ty_rptr(..) => {

branches/tmp/src/librustdoc/clean/mod.rs

@@ -49,7 +49,7 @@ use rustc::middle::stability;
 use std::rc::Rc;
 use std::u32;
 use std::str::Str as StrTrait; // Conflicts with Str variant
-use std::old_path::Path as FsPath; // Conflicts with Path struct
+use std::path::Path as FsPath; // Conflicts with Path struct
 
 use core::DocContext;
 use doctree;

branches/tmp/src/libserialize/serialize.rs

@@ -14,7 +14,7 @@
 Core encoding and decoding interfaces.
 */
 
-use std::old_path;
+use std::path;
 use std::rc::Rc;
 use std::cell::{Cell, RefCell};
 use std::sync::Arc;
@@ -538,29 +538,29 @@ macro_rules! tuple {
 
 tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
-impl Encodable for old_path::posix::Path {
+impl Encodable for path::posix::Path {
     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
         self.as_vec().encode(e)
     }
 }
 
-impl Decodable for old_path::posix::Path {
-    fn decode<D: Decoder>(d: &mut D) -> Result<old_path::posix::Path, D::Error> {
+impl Decodable for path::posix::Path {
+    fn decode<D: Decoder>(d: &mut D) -> Result<path::posix::Path, D::Error> {
         let bytes: Vec<u8> = try!(Decodable::decode(d));
-        Ok(old_path::posix::Path::new(bytes))
+        Ok(path::posix::Path::new(bytes))
     }
 }
 
-impl Encodable for old_path::windows::Path {
+impl Encodable for path::windows::Path {
     fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
         self.as_vec().encode(e)
     }
 }
 
-impl Decodable for old_path::windows::Path {
-    fn decode<D: Decoder>(d: &mut D) -> Result<old_path::windows::Path, D::Error> {
+impl Decodable for path::windows::Path {
+    fn decode<D: Decoder>(d: &mut D) -> Result<path::windows::Path, D::Error> {
         let bytes: Vec<u8> = try!(Decodable::decode(d));
-        Ok(old_path::windows::Path::new(bytes))
+        Ok(path::windows::Path::new(bytes))
     }
 }
 

branches/tmp/src/libstd/env.rs

@@ -57,7 +57,7 @@ pub fn current_dir() -> IoResult<Path> {
 ///
 /// ```rust
 /// use std::env;
-/// use std::old_path::Path;
+/// use std::path::Path;
 ///
 /// let root = Path::new("/");
 /// assert!(env::set_current_dir(&root).is_ok());