---

yaml
---
r: 129785
b: refs/heads/auto
c: 2e92c67
h: refs/heads/master
i:
  129783: 7d17af6
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 9a8233d3772fbdb3d496aac3e4693e6d4c30e125
+refs/heads/auto: 2e92c67dc0318a52fe42c3c0bca408f76c7feb61
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/crates.mk

@@ -96,7 +96,7 @@ DEPS_test := std getopts serialize rbml term time regex native:rust_test_helpers
 DEPS_time := std serialize
 DEPS_rand := core
 DEPS_url := std
-DEPS_log := std
+DEPS_log := std regex
 DEPS_regex := std
 DEPS_regex_macros = rustc syntax std regex
 DEPS_fmt_macros = std

branches/auto/src/liballoc/boxed.rs

@@ -105,9 +105,9 @@ pub trait BoxAny {
 }
 
 #[stable]
-impl BoxAny for Box<Any> {
+impl BoxAny for Box<Any+'static> {
     #[inline]
-    fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
+    fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any+'static>> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
@@ -132,7 +132,7 @@ impl<T: fmt::Show> fmt::Show for Box<T> {
     }
 }
 
-impl fmt::Show for Box<Any> {
+impl fmt::Show for Box<Any+'static> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.pad("Box<Any>")
     }

branches/auto/src/libcollections/dlist.rs

@@ -49,27 +49,46 @@ struct Node<T> {
     value: T,
 }
 
-/// An iterator over references to the items of a `DList`.
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
 pub struct Items<'a, T> {
     head: &'a Link<T>,
     tail: Rawlink<Node<T>>,
     nelem: uint,
 }
 
+/// An iterator over references to the items of a `DList`.
+#[cfg(not(stage0))]
+pub struct Items<'a, T:'a> {
+    head: &'a Link<T>,
+    tail: Rawlink<Node<T>>,
+    nelem: uint,
+}
+
 // FIXME #11820: the &'a Option<> of the Link stops clone working.
 impl<'a, T> Clone for Items<'a, T> {
     fn clone(&self) -> Items<'a, T> { *self }
 }
 
-/// An iterator over mutable references to the items of a `DList`.
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
 pub struct MutItems<'a, T> {
     list: &'a mut DList<T>,
     head: Rawlink<Node<T>>,
     tail: Rawlink<Node<T>>,
     nelem: uint,
 }
 
-/// A consuming iterator over the items of a `DList`.
+/// An iterator over mutable references to the items of a `DList`.
+#[cfg(not(stage0))]
+pub struct MutItems<'a, T:'a> {
+    list: &'a mut DList<T>,
+    head: Rawlink<Node<T>>,
+    tail: Rawlink<Node<T>>,
+    nelem: uint,
+}
+
+/// An iterator over mutable references to the items of a `DList`.
 #[deriving(Clone)]
 pub struct MoveItems<T> {
     list: DList<T>

branches/auto/src/libcollections/priority_queue.rs

@@ -515,11 +515,18 @@ impl<T: Ord> PriorityQueue<T> {
     }
 }
 
-/// `PriorityQueue` iterator.
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
 pub struct Items <'a, T> {
     iter: slice::Items<'a, T>,
 }
 
+/// `PriorityQueue` iterator.
+#[cfg(not(stage0))]
+pub struct Items <'a, T:'a> {
+    iter: slice::Items<'a, T>,
+}
+
 impl<'a, T> Iterator<&'a T> for Items<'a, T> {
     #[inline]
     fn next(&mut self) -> Option<(&'a T)> { self.iter.next() }

branches/auto/src/libcollections/ringbuf.rs

@@ -293,14 +293,24 @@ impl<T> RingBuf<T> {
     }
 }
 
-/// `RingBuf` iterator.
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
 pub struct Items<'a, T> {
     lo: uint,
     index: uint,
     rindex: uint,
     elts: &'a [Option<T>],
 }
 
+/// `RingBuf` iterator.
+#[cfg(not(stage0))]
+pub struct Items<'a, T:'a> {
+    lo: uint,
+    index: uint,
+    rindex: uint,
+    elts: &'a [Option<T>],
+}
+
 impl<'a, T> Iterator<&'a T> for Items<'a, T> {
     #[inline]
     fn next(&mut self) -> Option<&'a T> {
@@ -348,13 +358,22 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
     }
 }
 
-/// `RingBuf` mutable iterator.
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
 pub struct MutItems<'a, T> {
     remaining1: &'a mut [Option<T>],
     remaining2: &'a mut [Option<T>],
     nelts: uint,
 }
 
+/// `RingBuf` mutable iterator.
+#[cfg(not(stage0))]
+pub struct MutItems<'a, T:'a> {
+    remaining1: &'a mut [Option<T>],
+    remaining2: &'a mut [Option<T>],
+    nelts: uint,
+}
+
 impl<'a, T> Iterator<&'a mut T> for MutItems<'a, T> {
     #[inline]
     #[allow(deprecated)] // mut_shift_ref

branches/auto/src/libcollections/smallintmap.rs

@@ -489,19 +489,37 @@ macro_rules! double_ended_iterator {
     }
 }
 
-/// Forward iterator over a map.
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
 pub struct Entries<'a, T> {
     front: uint,
     back: uint,
     iter: slice::Items<'a, Option<T>>
 }
 
+/// Forward iterator over a map.
+#[cfg(not(stage0))]
+pub struct Entries<'a, T:'a> {
+    front: uint,
+    back: uint,
+    iter: slice::Items<'a, Option<T>>
+}
+
 iterator!(impl Entries -> (uint, &'a T), get_ref)
 double_ended_iterator!(impl Entries -> (uint, &'a T), get_ref)
 
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
+pub struct MutEntries<'a, T> {
+    front: uint,
+    back: uint,
+    iter: slice::MutItems<'a, Option<T>>
+}
+
 /// Forward iterator over the key-value pairs of a map, with the
 /// values being mutable.
-pub struct MutEntries<'a, T> {
+#[cfg(not(stage0))]
+pub struct MutEntries<'a, T:'a> {
     front: uint,
     back: uint,
     iter: slice::MutItems<'a, Option<T>>