---

yaml
---
r: 134895
b: refs/heads/snap-stage3
c: bd322f4
h: refs/heads/master
i:
  134893: 432c4c6
  134891: 48d10bf
  134887: e0b0413
  134879: 35df117
v: v3

Author: steveklabnik

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 7eb9337dace88c5ded431aa7507f06d50619131b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: f351e676cbe594893a043d52a9cd6149c3f47082
+refs/heads/snap-stage3: bd322f4c1fdc1e2109c388fd424378ff7be644ca
 refs/heads/try: 14378ea357c06c23607ca61ade44f60a7a64a1c7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/CONTRIBUTING.md

@@ -4,12 +4,6 @@ If you're just reporting a bug, please see:
 
 http://doc.rust-lang.org/complement-bugreport.html
 
-## Submitting an issue
-
-Please submit issues here for bug reports or implementation details. For feature
-requests, language changes, or major changes to the libraries, please submit an
-issue against the [RFCs repository](https://github.com/rust-lang/rfcs).
-
 ## Pull request procedure
 
 Pull requests should be targeted at Rust's `master` branch.

branches/snap-stage3/src/liballoc/arc.rs

@@ -311,13 +311,13 @@ mod tests {
 
         task::spawn(proc() {
             let arc_v: Arc<Vec<int>> = rx.recv();
-            assert_eq!((*arc_v)[3], 4);
+            assert_eq!(*arc_v.get(3), 4);
         });
 
         tx.send(arc_v.clone());
 
-        assert_eq!((*arc_v)[2], 3);
-        assert_eq!((*arc_v)[4], 5);
+        assert_eq!(*arc_v.get(2), 3);
+        assert_eq!(*arc_v.get(4), 5);
 
         info!("{:?}", arc_v);
     }

branches/snap-stage3/src/libcollections/lib.rs

@@ -131,7 +131,7 @@ pub trait MutableMap<K, V>: Map<K, V> + Mutable {
     /// let mut map = HashMap::new();
     /// assert_eq!(map.insert("key", 2i), true);
     /// assert_eq!(map.insert("key", 9i), false);
-    /// assert_eq!(map["key"], 9i);
+    /// assert_eq!(map.get(&"key"), &9i);
     /// ```
     #[inline]
     fn insert(&mut self, key: K, value: V) -> bool {
@@ -171,7 +171,7 @@ pub trait MutableMap<K, V>: Map<K, V> + Mutable {
     ///
     /// map.insert("a", 1i);
     /// assert_eq!(map.swap("a", 37i), Some(1i));
-    /// assert_eq!(map["a"], 37i);
+    /// assert_eq!(map.get(&"a"), &37i);
     /// ```
     fn swap(&mut self, k: K, v: V) -> Option<V>;
 
@@ -203,7 +203,7 @@ pub trait MutableMap<K, V>: Map<K, V> + Mutable {
     ///     Some(x) => *x = 7i,
     ///     None => (),
     /// }
-    /// assert_eq!(map["a"], 7i);
+    /// assert_eq!(map.get(&"a"), &7i);
     /// ```
     fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V>;
 }

branches/snap-stage3/src/libcollections/ringbuf.rs

@@ -542,7 +542,6 @@ mod tests {
     use vec::Vec;
 
     #[test]
-    #[allow(deprecated)]
     fn test_simple() {
         let mut d = RingBuf::new();
         assert_eq!(d.len(), 0u);
@@ -588,7 +587,6 @@ mod tests {
     }
 
     #[test]
-    #[allow(deprecated)]
     fn test_boxes() {
         let a: Gc<int> = box(GC) 5;
         let b: Gc<int> = box(GC) 72;

branches/snap-stage3/src/libcollections/slice.rs

@@ -904,7 +904,6 @@ mod tests {
     }
 
     #[test]
-    #[allow(deprecated)]
     fn test_initn() {
         let mut a = vec![11i, 12, 13];
         let b: &[int] = &[11, 12, 13];
@@ -1304,7 +1303,6 @@ mod tests {
     }
 
     #[test]
-    #[allow(deprecated)]
     fn test_bsearch_elem() {
         assert_eq!([1i,2,3,4,5].bsearch_elem(&5), Some(4));
         assert_eq!([1i,2,3,4,5].bsearch_elem(&4), Some(3));
@@ -1352,11 +1350,11 @@ mod tests {
     #[test]
     fn test_reverse() {
         let mut v: Vec<int> = vec![10i, 20];
-        assert_eq!(v[0], 10);
-        assert_eq!(v[1], 20);
+        assert_eq!(*v.get(0), 10);
+        assert_eq!(*v.get(1), 20);
         v.reverse();
-        assert_eq!(v[0], 20);
-        assert_eq!(v[1], 10);
+        assert_eq!(*v.get(0), 20);
+        assert_eq!(*v.get(1), 10);
 
         let mut v3: Vec<int> = vec![];
         v3.reverse();
@@ -1464,7 +1462,6 @@ mod tests {
     }
 
     #[test]
-    #[allow(deprecated)]
     fn test_shift() {
         let mut x = vec![1i, 2, 3];
         assert_eq!(x.shift(), Some(1));
@@ -1904,7 +1901,6 @@ mod tests {
     }
 
     #[test]
-    #[allow(deprecated)]
     fn test_copy_from() {
         let mut a = [1i,2,3,4,5];
         let b = [6i,7,8];

branches/snap-stage3/src/libcollections/smallintmap.rs

@@ -348,11 +348,11 @@ impl<V:Clone> SmallIntMap<V> {
     /// let mut map = SmallIntMap::new();
     ///
     /// // Key does not exist, will do a simple insert
-    /// assert!(map.update(1, vec![1i, 2], |mut old, new| { old.extend(new.into_iter()); old }));
+    /// assert!(map.update(1, vec![1i, 2], |old, new| old.append(new.as_slice())));
     /// assert_eq!(map[1], vec![1i, 2]);
     ///
     /// // Key exists, update the value
-    /// assert!(!map.update(1, vec![3i, 4], |mut old, new| { old.extend(new.into_iter()); old }));
+    /// assert!(!map.update(1, vec![3i, 4], |old, new| old.append(new.as_slice())));
     /// assert_eq!(map[1], vec![1i, 2, 3, 4]);
     /// ```
     pub fn update(&mut self, key: uint, newval: V, ff: |V, V| -> V) -> bool {
@@ -452,7 +452,7 @@ impl<V> Index<uint, V> for SmallIntMap<V> {
 }*/
 
 macro_rules! iterator {
-    (impl $name:ident -> $elem:ty, $($getter:ident),+) => {
+    (impl $name:ident -> $elem:ty, $getter:ident) => {
         impl<'a, T> Iterator<$elem> for $name<'a, T> {
             #[inline]
             fn next(&mut self) -> Option<$elem> {
@@ -462,7 +462,7 @@ macro_rules! iterator {
                             if elem.is_some() {
                                 let index = self.front;
                                 self.front += 1;
-                                return Some((index, elem $(. $getter ())+));
+                                return Some((index, elem. $getter ()));
                             }
                         }
                         _ => ()
@@ -481,7 +481,7 @@ macro_rules! iterator {
 }
 
 macro_rules! double_ended_iterator {
-    (impl $name:ident -> $elem:ty, $($getter:ident),+) => {
+    (impl $name:ident -> $elem:ty, $getter:ident) => {
         impl<'a, T> DoubleEndedIterator<$elem> for $name<'a, T> {
             #[inline]
             fn next_back(&mut self) -> Option<$elem> {
@@ -490,7 +490,7 @@ macro_rules! double_ended_iterator {
                         Some(elem) => {
                             if elem.is_some() {
                                 self.back -= 1;
-                                return Some((self.back, elem$(. $getter ())+));
+                                return Some((self.back, elem. $getter ()));
                             }
                         }
                         _ => ()
@@ -510,8 +510,8 @@ pub struct Entries<'a, T:'a> {
     iter: slice::Items<'a, Option<T>>
 }
 
-iterator!(impl Entries -> (uint, &'a T), as_ref, unwrap)
-double_ended_iterator!(impl Entries -> (uint, &'a T), as_ref, unwrap)
+iterator!(impl Entries -> (uint, &'a T), get_ref)
+double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
 
 /// Forward iterator over the key-value pairs of a map, with the
 /// values being mutable.
@@ -521,8 +521,8 @@ pub struct MutEntries<'a, T:'a> {
     iter: slice::MutItems<'a, Option<T>>
 }
 
-iterator!(impl MutEntries -> (uint, &'a mut T), as_mut, unwrap)
-double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), as_mut, unwrap)
+iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
+double_ended_iterator!(impl MutEntries -> (uint, &'a mut T), get_mut_ref)
 
 /// Forward iterator over the keys of a map
 pub type Keys<'a, T> =

branches/snap-stage3/src/libcollections/trie.rs

@@ -434,7 +434,7 @@ impl<T> TrieMap<T> {
     fn bound_mut<'a>(&'a mut self, key: uint, upper: bool) -> MutEntries<'a, T> {
         bound!(MutEntries, self = self,
                key = key, is_upper = upper,
-               slice_from = slice_from_mut, iter = iter_mut,
+               slice_from = mut_slice_from, iter = mut_iter,
                mutability = mut)
     }
 
@@ -1020,7 +1020,7 @@ macro_rules! iterator_impl {
 }
 
 iterator_impl! { Entries, iter = iter, mutability = }
-iterator_impl! { MutEntries, iter = iter_mut, mutability = mut }
+iterator_impl! { MutEntries, iter = mut_iter, mutability = mut }
 
 /// A forward iterator over a set.
 pub struct SetItems<'a> {

branches/snap-stage3/src/libcollections/vec.rs

@@ -960,7 +960,6 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```
-    /// #![allow(deprecated)]
     /// let vec = vec![1i, 2, 3, 4];
     /// assert!(vec.tailn(2) == [3, 4]);
     /// ```
@@ -1066,7 +1065,6 @@ impl<T> Vec<T> {
     /// # Example
     ///
     /// ```
-    /// #![allow(deprecated)]
     /// let mut vec = vec![1i, 2, 3];
     /// assert!(vec.shift() == Some(1));
     /// assert_eq!(vec, vec![2, 3]);

branches/snap-stage3/src/libcore/any.rs

@@ -94,7 +94,7 @@ pub enum Void { }
 pub trait Any: AnyPrivate {}
 
 /// An inner trait to ensure that only this module can call `get_type_id()`.
-pub trait AnyPrivate {
+trait AnyPrivate {
     /// Get the `TypeId` of `self`
     fn get_type_id(&self) -> TypeId;
 }

branches/snap-stage3/src/libcore/clone.rs

@@ -25,9 +25,7 @@ the `clone` method.
 
 /// A common trait for cloning an object.
 pub trait Clone {
-    /// Returns a copy of the value. The contents of owned pointers
-    /// are copied to maintain uniqueness, while the contents of
-    /// managed pointers are not copied.
+    /// Returns a copy of the value.
     fn clone(&self) -> Self;
 
     /// Perform copy-assignment from `source`.

branches/snap-stage3/src/libcore/iter.rs

@@ -2178,6 +2178,7 @@ pub type Iterate<'a, T> = Unfold<'a, T, IterateState<'a, T>>;
 
 /// Creates a new iterator that produces an infinite sequence of
 /// repeated applications of the given function `f`.
+#[allow(visible_private_types)]
 pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> {
     Unfold::new((f, Some(seed), true), |st| {
         let &(ref mut f, ref mut val, ref mut first) = st;

branches/snap-stage3/src/libcore/slice.rs

@@ -1062,11 +1062,11 @@ pub trait MutableCloneableSlice<T> {
     /// let mut dst = [0i, 0, 0];
     /// let src = [1i, 2];
     ///
-    /// assert!(dst.clone_from_slice(src) == 2);
+    /// assert!(dst.copy_from(src) == 2);
     /// assert!(dst == [1, 2, 0]);
     ///
     /// let src2 = [3i, 4, 5, 6];
-    /// assert!(dst.clone_from_slice(src2) == 3);
+    /// assert!(dst.copy_from(src2) == 3);
     /// assert!(dst == [3i, 4, 5]);
     /// ```
     fn clone_from_slice(self, &[T]) -> uint;

branches/snap-stage3/src/libcoretest/cmp.rs

@@ -42,7 +42,6 @@ fn test_ordering_order() {
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_lexical_ordering() {
     fn t(o1: Ordering, o2: Ordering, e: Ordering) {
         assert_eq!(lexical_ordering(o1, o2), e);

branches/snap-stage3/src/libcoretest/option.rs

@@ -244,7 +244,6 @@ fn test_ord() {
 }
 
 #[test]
-#[allow(deprecated)]
 fn test_mutate() {
     let mut x = Some(3i);
     assert!(x.mutate(|i| i+1));

branches/snap-stage3/src/libdebug/repr.rs

@@ -32,7 +32,7 @@ macro_rules! try( ($me:expr, $e:expr) => (
 
 /// Representations
 
-pub trait Repr {
+trait Repr {
     fn write_repr(&self, writer: &mut io::Writer) -> io::IoResult<()>;
 }
 

branches/snap-stage3/src/libgetopts/lib.rs

@@ -1142,7 +1142,7 @@ mod tests {
           Ok(ref m) => {
             // The next variable after the flag is just a free argument
 
-            assert!(m.free[0] == "20".to_string());
+            assert!(*m.free.get(0) == "20".to_string());
           }
           _ => fail!()
         }
@@ -1298,8 +1298,8 @@ mod tests {
               assert!(m.opt_present("t"));
               assert_eq!(m.opt_str("t").unwrap(), "20".to_string());
               let pair = m.opt_strs("test");
-              assert!(pair[0] == "20".to_string());
-              assert!(pair[1] == "30".to_string());
+              assert!(*pair.get(0) == "20".to_string());
+              assert!(*pair.get(1) == "30".to_string());
           }
           _ => fail!()
         }
@@ -1351,19 +1351,19 @@ mod tests {
         let rs = getopts(args.as_slice(), opts.as_slice());
         match rs {
           Ok(ref m) => {
-            assert!(m.free[0] == "prog".to_string());
-            assert!(m.free[1] == "free1".to_string());
+            assert!(*m.free.get(0) == "prog".to_string());
+            assert!(*m.free.get(1) == "free1".to_string());
             assert_eq!(m.opt_str("s").unwrap(), "20".to_string());
-            assert!(m.free[2] == "free2".to_string());
+            assert!(*m.free.get(2) == "free2".to_string());
             assert!((m.opt_present("flag")));
             assert_eq!(m.opt_str("long").unwrap(), "30".to_string());
             assert!((m.opt_present("f")));
             let pair = m.opt_strs("m");
-            assert!(pair[0] == "40".to_string());
-            assert!(pair[1] == "50".to_string());
+            assert!(*pair.get(0) == "40".to_string());
+            assert!(*pair.get(1) == "50".to_string());
             let pair = m.opt_strs("n");
-            assert!(pair[0] == "-A B".to_string());
-            assert!(pair[1] == "-60 70".to_string());
+            assert!(*pair.get(0) == "-A B".to_string());
+            assert!(*pair.get(1) == "-60 70".to_string());
             assert!((!m.opt_present("notpresent")));
           }
           _ => fail!()

branches/snap-stage3/src/libglob/lib.rs

@@ -336,7 +336,6 @@ impl Pattern {
      * # Example
      *
      * ```rust
-     * #![allow(deprecated)]
      * use glob::Pattern;
      *
      * assert!(Pattern::new("c?t").matches("cat"));

branches/snap-stage3/src/libgreen/lib.rs

@@ -218,7 +218,7 @@
 
 // NB this does *not* include globs, please keep it that way.
 #![feature(macro_rules, phase, default_type_params)]
-#![allow(deprecated)]
+#![allow(visible_private_types, deprecated)]
 
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 #[cfg(test)] extern crate rustuv;
@@ -385,7 +385,7 @@ pub struct SchedPool {
 /// keep track of how many tasks are currently running in the pool and then
 /// sending on a channel once the entire pool has been drained of all tasks.
 #[deriving(Clone)]
-pub struct TaskState {
+struct TaskState {
     cnt: Arc<AtomicUint>,
     done: Sender<()>,
 }

branches/snap-stage3/src/libnative/io/timer_unix.rs

@@ -66,14 +66,15 @@ pub struct Timer {
     inner: Option<Box<Inner>>,
 }
 
-pub struct Inner {
+struct Inner {
     cb: Option<Box<rtio::Callback + Send>>,
     interval: u64,
     repeat: bool,
     target: u64,
     id: uint,
 }
 
+#[allow(visible_private_types)]
 pub enum Req {
     // Add a new timer to the helper thread.
     NewTimer(Box<Inner>),