---

yaml
---
r: 129782
b: refs/heads/auto
c: 3a52ef4
h: refs/heads/master
v: v3

Author: aturon

[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: 1a33d7a54170cd2904cebc7a6fd2d1da471ff64e
+refs/heads/auto: 3a52ef4613f85fba1ecfd8746388bf34a5499bf9
 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 regex
+DEPS_log := std
 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+'static> {
+impl BoxAny for Box<Any> {
     #[inline]
-    fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any+'static>> {
+    fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
         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+'static> {
+impl fmt::Show for Box<Any> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.pad("Box<Any>")
     }

branches/auto/src/libcollections/dlist.rs

@@ -49,17 +49,8 @@ struct Node<T> {
     value: T,
 }
 
-/// 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> {
+pub struct Items<'a, T> {
     head: &'a Link<T>,
     tail: Rawlink<Node<T>>,
     nelem: uint,
@@ -70,25 +61,15 @@ impl<'a, T> Clone for Items<'a, T> {
     fn clone(&self) -> Items<'a, T> { *self }
 }
 
-/// 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,
-}
-
 /// An iterator over mutable references to the items of a `DList`.
-#[cfg(not(stage0))]
-pub struct MutItems<'a, T:'a> {
+pub struct MutItems<'a, T> {
     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`.
+/// A consuming iterator over the items of a `DList`.
 #[deriving(Clone)]
 pub struct MoveItems<T> {
     list: DList<T>

branches/auto/src/libcollections/priority_queue.rs

@@ -515,15 +515,8 @@ impl<T: Ord> PriorityQueue<T> {
     }
 }
 
-/// 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> {
+pub struct Items <'a, T> {
     iter: slice::Items<'a, T>,
 }
 

branches/auto/src/libcollections/ringbuf.rs

@@ -293,18 +293,8 @@ impl<T> RingBuf<T> {
     }
 }
 
-/// 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> {
+pub struct Items<'a, T> {
     lo: uint,
     index: uint,
     rindex: uint,
@@ -358,17 +348,8 @@ impl<'a, T> RandomAccessIterator<&'a T> for Items<'a, T> {
     }
 }
 
-/// 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> {
+pub struct MutItems<'a, T> {
     remaining1: &'a mut [Option<T>],
     remaining2: &'a mut [Option<T>],
     nelts: uint,

branches/auto/src/libcollections/smallintmap.rs

@@ -489,17 +489,8 @@ macro_rules! double_ended_iterator {
     }
 }
 
-/// 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> {
+pub struct Entries<'a, T> {
     front: uint,
     back: uint,
     iter: slice::Items<'a, Option<T>>
@@ -508,18 +499,9 @@ pub struct Entries<'a, T:'a> {
 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.
-#[cfg(not(stage0))]
-pub struct MutEntries<'a, T:'a> {
+pub struct MutEntries<'a, T> {
     front: uint,
     back: uint,
     iter: slice::MutItems<'a, Option<T>>

branches/auto/src/libcollections/treemap.rs

@@ -668,8 +668,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
+/// A lazy forward iterator over a map.
 pub struct Entries<'a, K, V> {
     stack: Vec<&'a TreeNode<K, V>>,
     // See the comment on MutEntries; this is just to allow
@@ -680,62 +679,14 @@ pub struct Entries<'a, K, V> {
     remaining_max: uint
 }
 
-/// Lazy forward iterator over a map
-#[cfg(not(stage0))]
-pub struct Entries<'a, K:'a, V:'a> {
-    stack: Vec<&'a TreeNode<K, V>>,
-    // See the comment on MutEntries; this is just to allow
-    // code-sharing (for this immutable-values iterator it *could* very
-    // well be Option<&'a TreeNode<K,V>>).
-    node: *const TreeNode<K, V>,
-    remaining_min: uint,
-    remaining_max: uint
-}
-
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
+/// Lazy backward iterator over a map.
 pub struct RevEntries<'a, K, V> {
     iter: Entries<'a, K, V>,
 }
 
-/// Lazy backward iterator over a map
-#[cfg(not(stage0))]
-pub struct RevEntries<'a, K:'a, V:'a> {
-    iter: Entries<'a, K, V>,
-}
-
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct MutEntries<'a, K, V> {
-    stack: Vec<&'a mut TreeNode<K, V>>,
-    // Unfortunately, we require some unsafe-ness to get around the
-    // fact that we would be storing a reference *into* one of the
-    // nodes in the stack.
-    //
-    // As far as the compiler knows, this would let us invalidate the
-    // reference by assigning a new value to this node's position in
-    // its parent, which would cause this current one to be
-    // deallocated so this reference would be invalid. (i.e. the
-    // compilers complaints are 100% correct.)
-    //
-    // However, as far as you humans reading this code know (or are
-    // about to know, if you haven't read far enough down yet), we are
-    // only reading from the TreeNode.{left,right} fields. the only
-    // thing that is ever mutated is the .value field (although any
-    // actual mutation that happens is done externally, by the
-    // iterator consumer). So, don't be so concerned, rustc, we've got
-    // it under control.
-    //
-    // (This field can legitimately be null.)
-    node: *mut TreeNode<K, V>,
-    remaining_min: uint,
-    remaining_max: uint
-}
-
-/// Lazy forward iterator over a map that allows for the mutation of
+/// A lazy forward iterator over a map that allows for the mutation of
 /// the values.
-#[cfg(not(stage0))]
-pub struct MutEntries<'a, K:'a, V:'a> {
+pub struct MutEntries<'a, K, V> {
     stack: Vec<&'a mut TreeNode<K, V>>,
     // Unfortunately, we require some unsafe-ness to get around the
     // fact that we would be storing a reference *into* one of the
@@ -761,17 +712,11 @@ pub struct MutEntries<'a, K:'a, V:'a> {
     remaining_max: uint
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
+/// Lazy backward iterator over a map.
 pub struct RevMutEntries<'a, K, V> {
     iter: MutEntries<'a, K, V>,
 }
 
-/// Lazy backward iterator over a map
-#[cfg(not(stage0))]
-pub struct RevMutEntries<'a, K:'a, V:'a> {
-    iter: MutEntries<'a, K, V>,
-}
 
 /// TreeMap keys iterator.
 pub type Keys<'a, K, V> =
@@ -940,7 +885,9 @@ fn mut_deref<K, V>(x: &mut Option<Box<TreeNode<K, V>>>)
     }
 }
 
-/// Lazy forward iterator over a map that consumes the map while iterating
+
+
+/// A lazy forward iterator over a map that consumes the map while iterating.
 pub struct MoveEntries<K, V> {
     stack: Vec<TreeNode<K, V>>,
     remaining: uint
@@ -1375,90 +1322,45 @@ impl<T: Ord> TreeSet<T> {
     }
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct SetItems<'a, T> {
-    iter: Entries<'a, T, ()>
-}
-
 /// A lazy forward iterator over a set.
-#[cfg(not(stage0))]
-pub struct SetItems<'a, T:'a> {
+pub struct SetItems<'a, T> {
     iter: Entries<'a, T, ()>
 }
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
+/// Lazy backward iterator over a set.
 pub struct RevSetItems<'a, T> {
     iter: RevEntries<'a, T, ()>
 }
 
-/// A lazy backward iterator over a set.
-#[cfg(not(stage0))]
-pub struct RevSetItems<'a, T:'a> {
-    iter: RevEntries<'a, T, ()>
-}
-
 /// A lazy forward iterator over a set that consumes the set while iterating.
 pub type MoveSetItems<T> = iter::Map<'static, (T, ()), T, MoveEntries<T, ()>>;
 
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct DifferenceItems<'a, T> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
 /// A lazy iterator producing elements in the set difference (in-order).
-#[cfg(not(stage0))]
-pub struct DifferenceItems<'a, T:'a> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct SymDifferenceItems<'a, T> {
+pub struct DifferenceItems<'a, T> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
 /// A lazy iterator producing elements in the set symmetric difference (in-order).
-#[cfg(not(stage0))]
-pub struct SymDifferenceItems<'a, T:'a> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct IntersectionItems<'a, T> {
+pub struct SymDifferenceItems<'a, T> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
 /// A lazy iterator producing elements in the set intersection (in-order).
-#[cfg(not(stage0))]
-pub struct IntersectionItems<'a, T:'a> {
-    a: Peekable<&'a T, SetItems<'a, T>>,
-    b: Peekable<&'a T, SetItems<'a, T>>,
-}
-
-/// Note: stage0-specific version that lacks bound on A.
-#[cfg(stage0)]
-pub struct UnionItems<'a, T> {
+pub struct IntersectionItems<'a, T> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
 /// A lazy iterator producing elements in the set union (in-order).
-#[cfg(not(stage0))]
-pub struct UnionItems<'a, T:'a> {
+pub struct UnionItems<'a, T> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
-/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
+/// Compare `x` and `y`, but return `short` if x is None and `long` if y is
+/// `None`.
 fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
                         short: Ordering, long: Ordering) -> Ordering {
     match (x, y) {