---

yaml
---
r: 130366
b: refs/heads/try
c: e29059f
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c964cb229bd342bdeb0b4506c3a6d32b03e575f6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 67b97ab6d2b7de9b69fd97dc171fcf8feec932ff
-refs/heads/try: 28d5878c1f0465c11c8e7a3085008b0c592d48d0
+refs/heads/try: e29059f508728e75e363955a64647b99714de630
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcollections/dlist.rs

@@ -49,7 +49,16 @@ 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> {
     head: &'a Link<T>,
     tail: Rawlink<Node<T>>,
@@ -61,7 +70,17 @@ 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> {
     list: &'a mut DList<T>,
     head: Rawlink<Node<T>>,

branches/try/src/libcollections/lib.rs

@@ -23,6 +23,9 @@
 #![feature(unsafe_destructor, import_shadowing)]
 #![no_std]
 
+// NOTE(stage0, pcwalton): Remove after snapshot.
+#![allow(unknown_features)]
+
 #[phase(plugin, link)] extern crate core;
 extern crate unicode;
 extern crate alloc;

branches/try/src/libcollections/priority_queue.rs

@@ -515,7 +515,14 @@ 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> {
     iter: slice::Items<'a, T>,
 }

branches/try/src/libcollections/ringbuf.rs

@@ -293,7 +293,17 @@ 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> {
     lo: uint,
     index: uint,
@@ -348,7 +358,16 @@ 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> {
     remaining1: &'a mut [Option<T>],
     remaining2: &'a mut [Option<T>],

branches/try/src/libcollections/smallintmap.rs

@@ -489,7 +489,16 @@ 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> {
     front: uint,
     back: uint,
@@ -499,8 +508,17 @@ 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> {
     front: uint,
     back: uint,

branches/try/src/libcollections/treemap.rs

@@ -668,7 +668,20 @@ impl<K: Ord, V> TreeMap<K, V> {
     }
 }
 
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
+pub struct Entries<'a, K, V> {
+    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
+}
+
 /// 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
@@ -679,13 +692,49 @@ pub struct Entries<'a, K:'a, V:'a> {
     remaining_max: uint
 }
 
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
+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
 /// the values.
+#[cfg(not(stage0))]
 pub struct MutEntries<'a, K:'a, V:'a> {
     stack: Vec<&'a mut TreeNode<K, V>>,
     // Unfortunately, we require some unsafe-ness to get around the
@@ -712,7 +761,14 @@ pub struct MutEntries<'a, K:'a, V:'a> {
     remaining_max: uint
 }
 
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
+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>,
 }
@@ -1319,38 +1375,84 @@ 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> {
     iter: Entries<'a, T, ()>
 }
 
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
+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> {
+    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> {
+    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> {
+    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> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,

branches/try/src/libcollections/trie.rs

@@ -857,16 +857,36 @@ fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,
     return ret;
 }
 
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
+pub struct Entries<'a, T> {
+    stack: [slice::Items<'a, Child<T>>, .. NUM_CHUNKS],
+    length: uint,
+    remaining_min: uint,
+    remaining_max: uint
+}
+
 /// A forward iterator over a map.
+#[cfg(not(stage0))]
 pub struct Entries<'a, T:'a> {
     stack: [slice::Items<'a, Child<T>>, .. NUM_CHUNKS],
     length: uint,
     remaining_min: uint,
     remaining_max: uint
 }
 
+/// Note: stage0-specific version that lacks bound on A.
+#[cfg(stage0)]
+pub struct MutEntries<'a, T> {
+    stack: [slice::MutItems<'a, Child<T>>, .. NUM_CHUNKS],
+    length: uint,
+    remaining_min: uint,
+    remaining_max: uint
+}
+
 /// A forward iterator over the key-value pairs of a map, with the
 /// values being mutable.
+#[cfg(not(stage0))]
 pub struct MutEntries<'a, T:'a> {
     stack: [slice::MutItems<'a, Child<T>>, .. NUM_CHUNKS],
     length: uint,

branches/try/src/libcore/cell.rs

@@ -324,12 +324,22 @@ impl<T: PartialEq> PartialEq for RefCell<T> {
 
 /// Wraps a borrowed reference to a value in a `RefCell` box.
 #[unstable]
+#[cfg(not(stage0))]
 pub struct Ref<'b, T:'b> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
     _parent: &'b RefCell<T>
 }
 
+/// Dox.
+#[unstable]
+#[cfg(stage0)]
+pub struct Ref<'b, T> {
+    // FIXME #12808: strange name to try to avoid interfering with
+    // field accesses of the contained type via Deref
+    _parent: &'b RefCell<T>
+}
+
 #[unsafe_destructor]
 #[unstable]
 impl<'b, T> Drop for Ref<'b, T> {
@@ -369,12 +379,22 @@ pub fn clone_ref<'b, T>(orig: &Ref<'b, T>) -> Ref<'b, T> {
 
 /// Wraps a mutable borrowed reference to a value in a `RefCell` box.
 #[unstable]
+#[cfg(not(stage0))]
 pub struct RefMut<'b, T:'b> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
     _parent: &'b RefCell<T>
 }
 
+/// Dox.
+#[unstable]
+#[cfg(stage0)]
+pub struct RefMut<'b, T> {
+    // FIXME #12808: strange name to try to avoid interfering with
+    // field accesses of the contained type via Deref
+    _parent: &'b RefCell<T>
+}
+
 #[unsafe_destructor]
 #[unstable]
 impl<'b, T> Drop for RefMut<'b, T> {