Register new snapshots

This commit is contained in:
Alex Crichton 2014-08-29 14:33:08 -07:00
parent 51d0d06410
commit d15d559739
52 changed files with 11 additions and 724 deletions

View File

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

View File

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

View File

@ -515,14 +515,7 @@ 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. /// `PriorityQueue` iterator.
#[cfg(not(stage0))]
pub struct Items <'a, T:'a> { pub struct Items <'a, T:'a> {
iter: slice::Items<'a, T>, iter: slice::Items<'a, T>,
} }

View File

@ -293,17 +293,7 @@ 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. /// `RingBuf` iterator.
#[cfg(not(stage0))]
pub struct Items<'a, T:'a> { pub struct Items<'a, T:'a> {
lo: uint, lo: uint,
index: uint, index: uint,
@ -358,16 +348,7 @@ 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. /// `RingBuf` mutable iterator.
#[cfg(not(stage0))]
pub struct MutItems<'a, T:'a> { pub struct MutItems<'a, T:'a> {
remaining1: &'a mut [Option<T>], remaining1: &'a mut [Option<T>],
remaining2: &'a mut [Option<T>], remaining2: &'a mut [Option<T>],

View File

@ -489,16 +489,7 @@ 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. /// Forward iterator over a map.
#[cfg(not(stage0))]
pub struct Entries<'a, T:'a> { pub struct Entries<'a, T:'a> {
front: uint, front: uint,
back: uint, back: uint,
@ -508,17 +499,8 @@ pub struct Entries<'a, T:'a> {
iterator!(impl Entries -> (uint, &'a T), get_ref) iterator!(impl Entries -> (uint, &'a T), get_ref)
double_ended_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 /// Forward iterator over the key-value pairs of a map, with the
/// values being mutable. /// values being mutable.
#[cfg(not(stage0))]
pub struct MutEntries<'a, T:'a> { pub struct MutEntries<'a, T:'a> {
front: uint, front: uint,
back: uint, back: uint,

View File

@ -668,20 +668,7 @@ 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 /// Lazy forward iterator over a map
#[cfg(not(stage0))]
pub struct Entries<'a, K:'a, V:'a> { pub struct Entries<'a, K:'a, V:'a> {
stack: Vec<&'a TreeNode<K, V>>, stack: Vec<&'a TreeNode<K, V>>,
// See the comment on MutEntries; this is just to allow // See the comment on MutEntries; this is just to allow
@ -692,49 +679,13 @@ pub struct Entries<'a, K:'a, V:'a> {
remaining_max: uint 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 /// Lazy backward iterator over a map
#[cfg(not(stage0))]
pub struct RevEntries<'a, K:'a, V:'a> { pub struct RevEntries<'a, K:'a, V:'a> {
iter: Entries<'a, K, V>, 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 /// Lazy forward iterator over a map that allows for the mutation of
/// the values. /// the values.
#[cfg(not(stage0))]
pub struct MutEntries<'a, K:'a, V:'a> { pub struct MutEntries<'a, K:'a, V:'a> {
stack: Vec<&'a mut TreeNode<K, V>>, stack: Vec<&'a mut TreeNode<K, V>>,
// Unfortunately, we require some unsafe-ness to get around the // Unfortunately, we require some unsafe-ness to get around the
@ -761,14 +712,7 @@ pub struct MutEntries<'a, K:'a, V:'a> {
remaining_max: uint 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 /// Lazy backward iterator over a map
#[cfg(not(stage0))]
pub struct RevMutEntries<'a, K:'a, V:'a> { pub struct RevMutEntries<'a, K:'a, V:'a> {
iter: MutEntries<'a, K, V>, iter: MutEntries<'a, K, V>,
} }
@ -1375,26 +1319,12 @@ 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. /// A lazy forward iterator over a set.
#[cfg(not(stage0))]
pub struct SetItems<'a, T:'a> { pub struct SetItems<'a, T:'a> {
iter: Entries<'a, T, ()> 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. /// A lazy backward iterator over a set.
#[cfg(not(stage0))]
pub struct RevSetItems<'a, T:'a> { pub struct RevSetItems<'a, T:'a> {
iter: RevEntries<'a, T, ()> iter: RevEntries<'a, T, ()>
} }
@ -1402,57 +1332,25 @@ pub struct RevSetItems<'a, T:'a> {
/// A lazy forward iterator over a set that consumes the set while iterating. /// A lazy forward iterator over a set that consumes the set while iterating.
pub type MoveSetItems<T> = iter::Map<'static, (T, ()), T, MoveEntries<T, ()>>; 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). /// A lazy iterator producing elements in the set difference (in-order).
#[cfg(not(stage0))]
pub struct DifferenceItems<'a, T:'a> { pub struct DifferenceItems<'a, T:'a> {
a: Peekable<&'a T, SetItems<'a, T>>, a: Peekable<&'a T, SetItems<'a, T>>,
b: 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). /// A lazy iterator producing elements in the set symmetric difference (in-order).
#[cfg(not(stage0))]
pub struct SymDifferenceItems<'a, T:'a> { pub struct SymDifferenceItems<'a, T:'a> {
a: Peekable<&'a T, SetItems<'a, T>>, a: Peekable<&'a T, SetItems<'a, T>>,
b: 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). /// A lazy iterator producing elements in the set intersection (in-order).
#[cfg(not(stage0))]
pub struct IntersectionItems<'a, T:'a> { pub struct IntersectionItems<'a, T:'a> {
a: Peekable<&'a T, SetItems<'a, T>>, a: Peekable<&'a T, SetItems<'a, T>>,
b: 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). /// 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> {
a: Peekable<&'a T, SetItems<'a, T>>, a: Peekable<&'a T, SetItems<'a, T>>,
b: Peekable<&'a T, SetItems<'a, T>>, b: Peekable<&'a T, SetItems<'a, T>>,

View File

@ -857,17 +857,7 @@ fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,
return ret; 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. /// A forward iterator over a map.
#[cfg(not(stage0))]
pub struct Entries<'a, T:'a> { pub struct Entries<'a, T:'a> {
stack: [slice::Items<'a, Child<T>>, .. NUM_CHUNKS], stack: [slice::Items<'a, Child<T>>, .. NUM_CHUNKS],
length: uint, length: uint,
@ -875,18 +865,8 @@ pub struct Entries<'a, T:'a> {
remaining_max: 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 /// A forward iterator over the key-value pairs of a map, with the
/// values being mutable. /// values being mutable.
#[cfg(not(stage0))]
pub struct MutEntries<'a, T:'a> { pub struct MutEntries<'a, T:'a> {
stack: [slice::MutItems<'a, Child<T>>, .. NUM_CHUNKS], stack: [slice::MutItems<'a, Child<T>>, .. NUM_CHUNKS],
length: uint, length: uint,

View File

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

View File

@ -102,18 +102,11 @@ pub fn try_finally<T,U,R>(mutate: &mut T,
try_fn(&mut *f.mutate, drop) try_fn(&mut *f.mutate, drop)
} }
#[cfg(not(stage0))]
struct Finallyalizer<'a,A:'a> { struct Finallyalizer<'a,A:'a> {
mutate: &'a mut A, mutate: &'a mut A,
dtor: |&mut A|: 'a dtor: |&mut A|: 'a
} }
#[cfg(stage0)]
struct Finallyalizer<'a,A> {
mutate: &'a mut A,
dtor: |&mut A|: 'a
}
#[unsafe_destructor] #[unsafe_destructor]
impl<'a,A> Drop for Finallyalizer<'a,A> { impl<'a,A> Drop for Finallyalizer<'a,A> {
#[inline] #[inline]

View File

@ -93,9 +93,6 @@ pub trait TyVisitor {
fn visit_char(&mut self) -> bool; fn visit_char(&mut self) -> bool;
fn visit_estr_slice(&mut self) -> bool; fn visit_estr_slice(&mut self) -> bool;
// NOTE: remove after snapshot
#[cfg(stage0)]
fn visit_estr_fixed(&mut self, n: uint, sz: uint, align: uint) -> bool;
fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
fn visit_uniq(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; fn visit_uniq(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
@ -103,11 +100,6 @@ pub trait TyVisitor {
fn visit_rptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; fn visit_rptr(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
fn visit_evec_slice(&mut self, mtbl: uint, inner: *const TyDesc) -> bool; fn visit_evec_slice(&mut self, mtbl: uint, inner: *const TyDesc) -> bool;
// NOTE: remove after snapshot
#[cfg(stage0)]
fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
mtbl: uint, inner: *const TyDesc) -> bool;
#[cfg(not(stage0))]
fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint, fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
inner: *const TyDesc) -> bool; inner: *const TyDesc) -> bool;

View File

@ -777,18 +777,10 @@ impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterato
/// A mutable reference to an iterator /// A mutable reference to an iterator
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[cfg(not(stage0))]
pub struct ByRef<'a, T:'a> { pub struct ByRef<'a, T:'a> {
iter: &'a mut T iter: &'a mut T
} }
/// Dox
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
#[cfg(stage0)]
pub struct ByRef<'a, T> {
iter: &'a mut T
}
impl<'a, A, T: Iterator<A>+'a> Iterator<A> for ByRef<'a, T> { impl<'a, A, T: Iterator<A>+'a> Iterator<A> for ByRef<'a, T> {
#[inline] #[inline]
fn next(&mut self) -> Option<A> { self.iter.next() } fn next(&mut self) -> Option<A> { self.iter.next() }

View File

@ -58,7 +58,7 @@
#![no_std] #![no_std]
#![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)] #![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
#![feature(simd, unsafe_destructor, issue_5723_bootstrap)] #![feature(simd, unsafe_destructor)]
#![deny(missing_doc)] #![deny(missing_doc)]
mod macros; mod macros;

View File

@ -51,12 +51,6 @@ pub struct Procedure {
/// ///
/// This struct does not have a `Repr` implementation /// This struct does not have a `Repr` implementation
/// because there is no way to refer to all trait objects generically. /// because there is no way to refer to all trait objects generically.
#[cfg(stage0)]
pub struct TraitObject {
pub vtable: *mut (),
pub data: *mut (),
}
#[cfg(not(stage0))]
pub struct TraitObject { pub struct TraitObject {
pub data: *mut (), pub data: *mut (),
pub vtable: *mut (), pub vtable: *mut (),

View File

@ -1125,7 +1125,6 @@ impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {}
/// An iterator over the slices of a vector separated by elements that /// An iterator over the slices of a vector separated by elements that
/// match a predicate function. /// match a predicate function.
#[cfg(not(stage0))]
#[experimental = "needs review"] #[experimental = "needs review"]
pub struct Splits<'a, T:'a> { pub struct Splits<'a, T:'a> {
v: &'a [T], v: &'a [T],
@ -1133,14 +1132,6 @@ pub struct Splits<'a, T:'a> {
finished: bool finished: bool
} }
/// Dox.
#[cfg(stage0)]
pub struct Splits<'a, T> {
v: &'a [T],
pred: |t: &T|: 'a -> bool,
finished: bool
}
#[experimental = "needs review"] #[experimental = "needs review"]
impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> { impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> {
#[inline] #[inline]
@ -1192,7 +1183,6 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Splits<'a, T> {
/// An iterator over the subslices of the vector which are separated /// An iterator over the subslices of the vector which are separated
/// by elements that match `pred`. /// by elements that match `pred`.
#[cfg(not(stage0))]
#[experimental = "needs review"] #[experimental = "needs review"]
pub struct MutSplits<'a, T:'a> { pub struct MutSplits<'a, T:'a> {
v: &'a mut [T], v: &'a mut [T],
@ -1200,14 +1190,6 @@ pub struct MutSplits<'a, T:'a> {
finished: bool finished: bool
} }
/// Dox
#[cfg(stage0)]
pub struct MutSplits<'a, T> {
v: &'a mut [T],
pred: |t: &T|: 'a -> bool,
finished: bool
}
#[experimental = "needs review"] #[experimental = "needs review"]
impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> { impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> {
#[inline] #[inline]
@ -1270,7 +1252,6 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> {
/// An iterator over the slices of a vector separated by elements that /// An iterator over the slices of a vector separated by elements that
/// match a predicate function, splitting at most a fixed number of times. /// match a predicate function, splitting at most a fixed number of times.
#[cfg(not(stage0))]
#[experimental = "needs review"] #[experimental = "needs review"]
pub struct SplitsN<'a, T:'a> { pub struct SplitsN<'a, T:'a> {
iter: Splits<'a, T>, iter: Splits<'a, T>,
@ -1278,14 +1259,6 @@ pub struct SplitsN<'a, T:'a> {
invert: bool invert: bool
} }
/// Dox.
#[cfg(stage0)]
pub struct SplitsN<'a, T> {
iter: Splits<'a, T>,
count: uint,
invert: bool
}
#[experimental = "needs review"] #[experimental = "needs review"]
impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> { impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> {
#[inline] #[inline]
@ -1315,17 +1288,6 @@ impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> {
/// An iterator over the (overlapping) slices of length `size` within /// An iterator over the (overlapping) slices of length `size` within
/// a vector. /// a vector.
#[cfg(stage0)]
#[deriving(Clone)]
#[experimental = "needs review"]
pub struct Windows<'a, T> {
v: &'a [T],
size: uint
}
/// An iterator over the (overlapping) slices of length `size` within
/// a vector.
#[cfg(not(stage0))]
#[deriving(Clone)] #[deriving(Clone)]
#[experimental = "needs review"] #[experimental = "needs review"]
pub struct Windows<'a, T:'a> { pub struct Windows<'a, T:'a> {
@ -1361,21 +1323,8 @@ impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
/// ///
/// When the vector len is not evenly divided by the chunk size, /// When the vector len is not evenly divided by the chunk size,
/// the last slice of the iteration will be the remainder. /// the last slice of the iteration will be the remainder.
#[cfg(stage0)]
#[deriving(Clone)] #[deriving(Clone)]
#[experimental = "needs review"] #[experimental = "needs review"]
pub struct Chunks<'a, T> {
v: &'a [T],
size: uint
}
/// An iterator over a vector in (non-overlapping) chunks (`size`
/// elements at a time).
///
/// When the vector len is not evenly divided by the chunk size,
/// the last slice of the iteration will be the remainder.
#[cfg(not(stage0))]
#[deriving(Clone)]
pub struct Chunks<'a, T:'a> { pub struct Chunks<'a, T:'a> {
v: &'a [T], v: &'a [T],
size: uint size: uint
@ -1447,20 +1396,12 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
/// An iterator over a vector in (non-overlapping) mutable chunks (`size` elements at a time). When /// An iterator over a vector in (non-overlapping) mutable chunks (`size` elements at a time). When
/// the vector len is not evenly divided by the chunk size, the last slice of the iteration will be /// the vector len is not evenly divided by the chunk size, the last slice of the iteration will be
/// the remainder. /// the remainder.
#[cfg(not(stage0))]
#[experimental = "needs review"] #[experimental = "needs review"]
pub struct MutChunks<'a, T:'a> { pub struct MutChunks<'a, T:'a> {
v: &'a mut [T], v: &'a mut [T],
chunk_size: uint chunk_size: uint
} }
/// Dox.
#[cfg(stage0)]
pub struct MutChunks<'a, T> {
v: &'a mut [T],
chunk_size: uint
}
#[experimental = "needs review"] #[experimental = "needs review"]
impl<'a, T> Iterator<&'a mut [T]> for MutChunks<'a, T> { impl<'a, T> Iterator<&'a mut [T]> for MutChunks<'a, T> {
#[inline] #[inline]

View File

@ -25,7 +25,7 @@
html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/")] html_root_url = "http://doc.rust-lang.org/master/")]
#![experimental] #![experimental]
#![feature(managed_boxes, macro_rules, issue_5723_bootstrap)] #![feature(managed_boxes, macro_rules)]
#![allow(experimental)] #![allow(experimental)]
pub mod fmt; pub mod fmt;

View File

@ -193,17 +193,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
true true
} }
// NOTE: remove after snapshot
#[cfg(stage0)]
fn visit_estr_fixed(&mut self, n: uint,
sz: uint,
align: uint) -> bool {
self.align(align);
if ! self.inner.visit_estr_fixed(n, sz, align) { return false; }
self.bump(sz);
true
}
fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool { fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
self.align_to::<Gc<u8>>(); self.align_to::<Gc<u8>>();
if ! self.inner.visit_box(mtbl, inner) { return false; } if ! self.inner.visit_box(mtbl, inner) { return false; }
@ -239,17 +228,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
true true
} }
#[cfg(stage0)]
fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
mtbl: uint, inner: *const TyDesc) -> bool {
self.align(align);
if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
return false;
}
self.bump(sz);
true
}
#[cfg(not(stage0))]
fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint, fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
inner: *const TyDesc) -> bool { inner: *const TyDesc) -> bool {
self.align(align); self.align(align);

View File

@ -274,12 +274,6 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
self.get::<&str>(|this, s| this.write_escaped_slice(*s)) self.get::<&str>(|this, s| this.write_escaped_slice(*s))
} }
// Type no longer exists, vestigial function.
// NOTE: remove after snapshot
#[cfg(stage0)]
fn visit_estr_fixed(&mut self, _n: uint, _sz: uint,
_align: uint) -> bool { fail!(); }
fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool { fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
try!(self, self.writer.write("box(GC) ".as_bytes())); try!(self, self.writer.write("box(GC) ".as_bytes()));
self.write_mut_qualifier(mtbl); self.write_mut_qualifier(mtbl);
@ -330,17 +324,6 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
}) })
} }
// NOTE: remove after snapshot
#[cfg(stage0)]
fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint,
_: uint, inner: *const TyDesc) -> bool {
let assumed_size = if sz == 0 { n } else { sz };
self.get::<()>(|this, b| {
this.write_vec_range(b, assumed_size, inner)
})
}
#[cfg(not(stage0))]
fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint, fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint,
inner: *const TyDesc) -> bool { inner: *const TyDesc) -> bool {
let assumed_size = if sz == 0 { n } else { sz }; let assumed_size = if sz == 0 { n } else { sz };

View File

@ -21,9 +21,6 @@
#![crate_type = "dylib"] #![crate_type = "dylib"]
#![feature(macro_rules, globs, import_shadowing)] #![feature(macro_rules, globs, import_shadowing)]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
use std::char; use std::char;
use std::str; use std::str;

View File

@ -91,9 +91,6 @@
#![feature(import_shadowing)] #![feature(import_shadowing)]
#![deny(missing_doc)] #![deny(missing_doc)]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[cfg(test)] extern crate debug; #[cfg(test)] extern crate debug;
#[cfg(test)] #[phase(plugin, link)] extern crate log; #[cfg(test)] #[phase(plugin, link)] extern crate log;

View File

@ -271,7 +271,6 @@ pub fn main() {
#![crate_type = "rlib"] #![crate_type = "rlib"]
#![crate_type = "dylib"] #![crate_type = "dylib"]
#![license = "MIT/ASL2"] #![license = "MIT/ASL2"]
#![feature(issue_5723_bootstrap)]
#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/")] html_root_url = "http://doc.rust-lang.org/master/")]

View File

@ -34,19 +34,11 @@ use std::slice;
/// Some clients will have a pre-allocated vector ready to hand off in /// Some clients will have a pre-allocated vector ready to hand off in
/// a slice; others will want to create the set on the fly and hand /// a slice; others will want to create the set on the fly and hand
/// off ownership, via `Growable`. /// off ownership, via `Growable`.
#[cfg(not(stage0))]
pub enum MaybeOwnedVector<'a,T:'a> { pub enum MaybeOwnedVector<'a,T:'a> {
Growable(Vec<T>), Growable(Vec<T>),
Borrowed(&'a [T]), Borrowed(&'a [T]),
} }
/// Stage0 only.
#[cfg(stage0)]
pub enum MaybeOwnedVector<'a,T> {
Growable(Vec<T>),
Borrowed(&'a [T]),
}
/// Trait for moving into a `MaybeOwnedVector` /// Trait for moving into a `MaybeOwnedVector`
pub trait IntoMaybeOwnedVector<'a,T> { pub trait IntoMaybeOwnedVector<'a,T> {
/// Moves self into a `MaybeOwnedVector` /// Moves self into a `MaybeOwnedVector`

View File

@ -79,13 +79,6 @@ pub struct Weighted<T> {
pub item: T, pub item: T,
} }
/// Note: stage0-specific version that lacks bound on A.
#[cfg(stage0)]
pub struct WeightedChoice<'a, T> {
items: &'a mut [Weighted<T>],
weight_range: Range<uint>
}
/// A distribution that selects from a finite collection of weighted items. /// A distribution that selects from a finite collection of weighted items.
/// ///
/// Each item has an associated weight that influences how likely it /// Each item has an associated weight that influences how likely it
@ -112,7 +105,6 @@ pub struct WeightedChoice<'a, T> {
/// println!("{}", wc.ind_sample(&mut rng)); /// println!("{}", wc.ind_sample(&mut rng));
/// } /// }
/// ``` /// ```
#[cfg(not(stage0))]
pub struct WeightedChoice<'a, T:'a> { pub struct WeightedChoice<'a, T:'a> {
items: &'a mut [Weighted<T>], items: &'a mut [Weighted<T>],
weight_range: Range<uint> weight_range: Range<uint>

View File

@ -269,16 +269,9 @@ pub trait Rng {
} }
} }
/// Note: stage0-specific version that lacks bound on A.
#[cfg(stage0)]
pub struct Generator<'a, T, R> {
rng: &'a mut R,
}
/// Iterator which will generate a stream of random items. /// Iterator which will generate a stream of random items.
/// ///
/// This iterator is created via the `gen_iter` method on `Rng`. /// This iterator is created via the `gen_iter` method on `Rng`.
#[cfg(not(stage0))]
pub struct Generator<'a, T, R:'a> { pub struct Generator<'a, T, R:'a> {
rng: &'a mut R, rng: &'a mut R,
} }
@ -289,16 +282,9 @@ impl<'a, T: Rand, R: Rng> Iterator<T> for Generator<'a, T, R> {
} }
} }
/// Note: stage0-specific version.
#[cfg(stage0)]
pub struct AsciiGenerator<'a, R> {
rng: &'a mut R,
}
/// Iterator which will continuously generate random ascii characters. /// Iterator which will continuously generate random ascii characters.
/// ///
/// This iterator is created via the `gen_ascii_chars` method on `Rng`. /// This iterator is created via the `gen_ascii_chars` method on `Rng`.
#[cfg(not(stage0))]
pub struct AsciiGenerator<'a, R:'a> { pub struct AsciiGenerator<'a, R:'a> {
rng: &'a mut R, rng: &'a mut R,
} }

View File

@ -24,7 +24,7 @@
html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://doc.rust-lang.org/master/", html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![feature(macro_rules, phase, issue_5723_bootstrap)] #![feature(macro_rules, phase)]
#![allow(missing_doc)] #![allow(missing_doc)]
extern crate serialize; extern crate serialize;
@ -662,14 +662,6 @@ pub mod writer {
pub type EncodeResult = io::IoResult<()>; pub type EncodeResult = io::IoResult<()>;
// rbml writing // rbml writing
#[cfg(stage0)]
pub struct Encoder<'a, W> {
pub writer: &'a mut W,
size_positions: Vec<uint>,
}
// rbml writing
#[cfg(not(stage0))]
pub struct Encoder<'a, W:'a> { pub struct Encoder<'a, W:'a> {
pub writer: &'a mut W, pub writer: &'a mut W,
size_positions: Vec<uint>, size_positions: Vec<uint>,

View File

@ -35,9 +35,6 @@
// LLVM to optimize these function calls to themselves! // LLVM to optimize these function calls to themselves!
#![no_builtins] #![no_builtins]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[cfg(test)] extern crate native; #[cfg(test)] extern crate native;
#[cfg(test)] extern crate test; #[cfg(test)] extern crate test;
#[cfg(test)] extern crate debug; #[cfg(test)] extern crate debug;

View File

@ -31,7 +31,6 @@ This API is completely unstable and subject to change.
#![allow(deprecated)] #![allow(deprecated)]
#![feature(macro_rules, globs, struct_variant, managed_boxes, quote)] #![feature(macro_rules, globs, struct_variant, managed_boxes, quote)]
#![feature(default_type_params, phase, unsafe_destructor)] #![feature(default_type_params, phase, unsafe_destructor)]
#![feature(issue_5723_bootstrap)]
#![allow(unknown_features)] // NOTE: Remove after next snapshot #![allow(unknown_features)] // NOTE: Remove after next snapshot
#![feature(rustc_diagnostic_macros)] #![feature(rustc_diagnostic_macros)]

View File

@ -80,13 +80,6 @@ pub trait DataFlowOperator : BitwiseOperator {
fn initial_value(&self) -> bool; fn initial_value(&self) -> bool;
} }
#[cfg(stage0)]
struct PropagationContext<'a, 'b, O> {
dfcx: &'a mut DataFlowContext<'b, O>,
changed: bool
}
#[cfg(not(stage0))]
struct PropagationContext<'a, 'b:'a, O:'a> { struct PropagationContext<'a, 'b:'a, O:'a> {
dfcx: &'a mut DataFlowContext<'b, O>, dfcx: &'a mut DataFlowContext<'b, O>,
changed: bool changed: bool

View File

@ -192,14 +192,6 @@ impl OverloadedCallType {
// supplies types from the tree. After type checking is complete, you // supplies types from the tree. After type checking is complete, you
// can just use the tcx as the typer. // can just use the tcx as the typer.
#[cfg(stage0)]
pub struct ExprUseVisitor<'d,'t,TYPER> {
typer: &'t TYPER,
mc: mc::MemCategorizationContext<'t,TYPER>,
delegate: &'d mut Delegate+'d,
}
#[cfg(not(stage0))]
pub struct ExprUseVisitor<'d,'t,TYPER:'t> { pub struct ExprUseVisitor<'d,'t,TYPER:'t> {
typer: &'t TYPER, typer: &'t TYPER,
mc: mc::MemCategorizationContext<'t,TYPER>, mc: mc::MemCategorizationContext<'t,TYPER>,

View File

@ -240,12 +240,6 @@ impl ast_node for ast::Pat {
fn span(&self) -> Span { self.span } fn span(&self) -> Span { self.span }
} }
#[cfg(stage0)]
pub struct MemCategorizationContext<'t,TYPER> {
typer: &'t TYPER
}
#[cfg(not(stage0))]
pub struct MemCategorizationContext<'t,TYPER:'t> { pub struct MemCategorizationContext<'t,TYPER:'t> {
typer: &'t TYPER typer: &'t TYPER
} }

View File

@ -340,21 +340,12 @@ struct ArmData<'a, 'b> {
* As we proceed `bound_ptrs` are filled with pointers to values to be bound, * As we proceed `bound_ptrs` are filled with pointers to values to be bound,
* these pointers are stored in llmatch variables just before executing `data` arm. * these pointers are stored in llmatch variables just before executing `data` arm.
*/ */
#[cfg(not(stage0))]
struct Match<'a, 'b:'a> { struct Match<'a, 'b:'a> {
pats: Vec<Gc<ast::Pat>>, pats: Vec<Gc<ast::Pat>>,
data: &'a ArmData<'a, 'b>, data: &'a ArmData<'a, 'b>,
bound_ptrs: Vec<(Ident, ValueRef)> bound_ptrs: Vec<(Ident, ValueRef)>
} }
///Dox
#[cfg(stage0)]
struct Match<'a, 'b> {
pats: Vec<Gc<ast::Pat>>,
data: &'a ArmData<'a, 'b>,
bound_ptrs: Vec<(Ident, ValueRef)>
}
impl<'a, 'b> Repr for Match<'a, 'b> { impl<'a, 'b> Repr for Match<'a, 'b> {
fn repr(&self, tcx: &ty::ctxt) -> String { fn repr(&self, tcx: &ty::ctxt) -> String {
if tcx.sess.verbose() { if tcx.sess.verbose() {

View File

@ -26,17 +26,7 @@ pub struct Exclusive<T> {
data: UnsafeCell<T>, data: UnsafeCell<T>,
} }
/// stage0 only
#[cfg(stage0)]
pub struct ExclusiveGuard<'a, T> {
// FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref
_data: &'a mut T,
_guard: mutex::LockGuard<'a>,
}
/// An RAII guard returned via `lock` /// An RAII guard returned via `lock`
#[cfg(not(stage0))]
pub struct ExclusiveGuard<'a, T:'a> { pub struct ExclusiveGuard<'a, T:'a> {
// FIXME #12808: strange name to try to avoid interfering with // FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref // field accesses of the contained type via Deref

View File

@ -19,13 +19,9 @@
#![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)] #![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)]
#![feature(linkage, lang_items, unsafe_destructor, default_type_params)] #![feature(linkage, lang_items, unsafe_destructor, default_type_params)]
#![feature(import_shadowing)] #![feature(import_shadowing)]
#![feature(issue_5723_bootstrap)]
#![no_std] #![no_std]
#![experimental] #![experimental]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[phase(plugin, link)] extern crate core; #[phase(plugin, link)] extern crate core;
extern crate alloc; extern crate alloc;
extern crate libc; extern crate libc;

View File

@ -144,7 +144,6 @@ unsafe fn get_local_map<'a>() -> Option<&'a mut Map> {
/// ///
/// The task-local data can be accessed through this value, and when this /// The task-local data can be accessed through this value, and when this
/// structure is dropped it will return the borrow on the data. /// structure is dropped it will return the borrow on the data.
#[cfg(not(stage0))]
pub struct Ref<T:'static> { pub struct Ref<T:'static> {
// FIXME #12808: strange names to try to avoid interfering with // FIXME #12808: strange names to try to avoid interfering with
// field accesses of the contained type via Deref // field accesses of the contained type via Deref
@ -152,15 +151,6 @@ pub struct Ref<T:'static> {
_marker: marker::NoSend _marker: marker::NoSend
} }
/// stage0 only
#[cfg(stage0)]
pub struct Ref<T> {
// FIXME #12808: strange names to try to avoid interfering with
// field accesses of the contained type via Deref
_inner: &'static TLDValueBox<T>,
_marker: marker::NoSend
}
fn key_to_key_value<T: 'static>(key: Key<T>) -> uint { fn key_to_key_value<T: 'static>(key: Key<T>) -> uint {
key as *const _ as uint key as *const _ as uint
} }

View File

@ -26,13 +26,6 @@ pub struct Access<T> {
inner: Arc<UnsafeCell<Inner<T>>>, inner: Arc<UnsafeCell<Inner<T>>>,
} }
#[cfg(stage0)]
pub struct Guard<'a, T> {
access: &'a mut Access<T>,
missile: Option<HomingMissile>,
}
#[cfg(not(stage0))]
pub struct Guard<'a, T:'static> { pub struct Guard<'a, T:'static> {
access: &'a mut Access<T>, access: &'a mut Access<T>,
missile: Option<HomingMissile>, missile: Option<HomingMissile>,

View File

@ -28,14 +28,6 @@ pub struct AccessTimeout<T> {
pub access: access::Access<T>, pub access: access::Access<T>,
} }
#[cfg(stage0)]
pub struct Guard<'a, T> {
state: &'a mut TimeoutState,
pub access: access::Guard<'a, T>,
pub can_timeout: bool,
}
#[cfg(not(stage0))]
pub struct Guard<'a, T:'static> { pub struct Guard<'a, T:'static> {
state: &'a mut TimeoutState, state: &'a mut TimeoutState,
pub access: access::Guard<'a, T>, pub access: access::Guard<'a, T>,

View File

@ -24,7 +24,6 @@ Core encoding and decoding interfaces.
html_root_url = "http://doc.rust-lang.org/master/", html_root_url = "http://doc.rust-lang.org/master/",
html_playground_url = "http://play.rust-lang.org/")] html_playground_url = "http://play.rust-lang.org/")]
#![feature(macro_rules, managed_boxes, default_type_params, phase)] #![feature(macro_rules, managed_boxes, default_type_params, phase)]
#![feature(issue_5723_bootstrap)]
// test harness access // test harness access
#[cfg(test)] #[cfg(test)]

View File

@ -409,32 +409,14 @@ mod table {
assert_eq!(size_of::<SafeHash>(), size_of::<u64>()) assert_eq!(size_of::<SafeHash>(), size_of::<u64>())
} }
/// Note: stage0-specific version that lacks bound.
#[cfg(stage0)]
pub struct Entries<'a, K, V> {
table: &'a RawTable<K, V>,
idx: uint,
elems_seen: uint,
}
/// Iterator over shared references to entries in a table. /// Iterator over shared references to entries in a table.
#[cfg(not(stage0))]
pub struct Entries<'a, K:'a, V:'a> { pub struct Entries<'a, K:'a, V:'a> {
table: &'a RawTable<K, V>, table: &'a RawTable<K, V>,
idx: uint, idx: uint,
elems_seen: uint, elems_seen: uint,
} }
/// Note: stage0-specific version that lacks bound.
#[cfg(stage0)]
pub struct MutEntries<'a, K, V> {
table: &'a mut RawTable<K, V>,
idx: uint,
elems_seen: uint,
}
/// Iterator over mutable references to entries in a table. /// Iterator over mutable references to entries in a table.
#[cfg(not(stage0))]
pub struct MutEntries<'a, K:'a, V:'a> { pub struct MutEntries<'a, K:'a, V:'a> {
table: &'a mut RawTable<K, V>, table: &'a mut RawTable<K, V>,
idx: uint, idx: uint,

View File

@ -37,25 +37,6 @@ use ptr::RawPtr;
/// ///
/// Any error other than `EndOfFile` that is produced by the underlying Reader /// Any error other than `EndOfFile` that is produced by the underlying Reader
/// is returned by the iterator and should be handled by the caller. /// is returned by the iterator and should be handled by the caller.
#[cfg(stage0)]
pub struct Bytes<'r, T> {
reader: &'r mut T,
}
/// An iterator that reads a single byte on each iteration,
/// until `.read_byte()` returns `EndOfFile`.
///
/// # Notes about the Iteration Protocol
///
/// The `Bytes` may yield `None` and thus terminate
/// an iteration, but continue to yield elements if iteration
/// is attempted again.
///
/// # Error
///
/// Any error other than `EndOfFile` that is produced by the underlying Reader
/// is returned by the iterator and should be handled by the caller.
#[cfg(not(stage0))]
pub struct Bytes<'r, T:'r> { pub struct Bytes<'r, T:'r> {
reader: &'r mut T, reader: &'r mut T,
} }

View File

@ -976,13 +976,6 @@ unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec<T>, start: uint, end: uint) -
}) })
} }
/// Note: stage0-specific version that lacks bound.
#[cfg(stage0)]
pub struct RefReader<'a, R> {
/// The underlying reader which this is referencing
inner: &'a mut R
}
/// A `RefReader` is a struct implementing `Reader` which contains a reference /// A `RefReader` is a struct implementing `Reader` which contains a reference
/// to another reader. This is often useful when composing streams. /// to another reader. This is often useful when composing streams.
/// ///
@ -1007,7 +1000,6 @@ pub struct RefReader<'a, R> {
/// ///
/// # } /// # }
/// ``` /// ```
#[cfg(not(stage0))]
pub struct RefReader<'a, R:'a> { pub struct RefReader<'a, R:'a> {
/// The underlying reader which this is referencing /// The underlying reader which this is referencing
inner: &'a mut R inner: &'a mut R
@ -1066,16 +1058,8 @@ pub trait Writer {
/// ///
/// This function will return any I/O error reported while formatting. /// This function will return any I/O error reported while formatting.
fn write_fmt(&mut self, fmt: &fmt::Arguments) -> IoResult<()> { fn write_fmt(&mut self, fmt: &fmt::Arguments) -> IoResult<()> {
// Note: stage0-specific version that lacks bound.
#[cfg(stage0)]
struct Adaptor<'a, T> {
inner: &'a mut T,
error: IoResult<()>,
}
// Create a shim which translates a Writer to a FormatWriter and saves // Create a shim which translates a Writer to a FormatWriter and saves
// off I/O errors. instead of discarding them // off I/O errors. instead of discarding them
#[cfg(not(stage0))]
struct Adaptor<'a, T:'a> { struct Adaptor<'a, T:'a> {
inner: &'a mut T, inner: &'a mut T,
error: IoResult<()>, error: IoResult<()>,
@ -1335,37 +1319,6 @@ impl<'a> Writer for &'a mut Writer+'a {
/// println!("input processed: {}", output.unwrap()); /// println!("input processed: {}", output.unwrap());
/// # } /// # }
/// ``` /// ```
#[cfg(stage0)]
pub struct RefWriter<'a, W> {
/// The underlying writer which this is referencing
inner: &'a mut W
}
/// A `RefWriter` is a struct implementing `Writer` which contains a reference
/// to another writer. This is often useful when composing streams.
///
/// # Example
///
/// ```
/// # fn main() {}
/// # fn process_input<R: Reader>(r: R) {}
/// # fn foo () {
/// use std::io::util::TeeReader;
/// use std::io::{stdin, MemWriter};
///
/// let mut output = MemWriter::new();
///
/// {
/// // Don't give ownership of 'output' to the 'tee'. Instead we keep a
/// // handle to it in the outer scope
/// let mut tee = TeeReader::new(stdin(), output.by_ref());
/// process_input(tee);
/// }
///
/// println!("input processed: {}", output.unwrap());
/// # }
/// ```
#[cfg(not(stage0))]
pub struct RefWriter<'a, W:'a> { pub struct RefWriter<'a, W:'a> {
/// The underlying writer which this is referencing /// The underlying writer which this is referencing
inner: &'a mut W inner: &'a mut W
@ -1399,25 +1352,6 @@ impl<T: Reader + Writer> Stream for T {}
/// ///
/// Any error other than `EndOfFile` that is produced by the underlying Reader /// Any error other than `EndOfFile` that is produced by the underlying Reader
/// is returned by the iterator and should be handled by the caller. /// is returned by the iterator and should be handled by the caller.
#[cfg(stage0)]
pub struct Lines<'r, T> {
buffer: &'r mut T,
}
/// An iterator that reads a line on each iteration,
/// until `.read_line()` encounters `EndOfFile`.
///
/// # Notes about the Iteration Protocol
///
/// The `Lines` may yield `None` and thus terminate
/// an iteration, but continue to yield elements if iteration
/// is attempted again.
///
/// # Error
///
/// Any error other than `EndOfFile` that is produced by the underlying Reader
/// is returned by the iterator and should be handled by the caller.
#[cfg(not(stage0))]
pub struct Lines<'r, T:'r> { pub struct Lines<'r, T:'r> {
buffer: &'r mut T, buffer: &'r mut T,
} }
@ -1445,25 +1379,6 @@ impl<'r, T: Buffer> Iterator<IoResult<String>> for Lines<'r, T> {
/// ///
/// Any error other than `EndOfFile` that is produced by the underlying Reader /// Any error other than `EndOfFile` that is produced by the underlying Reader
/// is returned by the iterator and should be handled by the caller. /// is returned by the iterator and should be handled by the caller.
#[cfg(stage0)]
pub struct Chars<'r, T> {
buffer: &'r mut T
}
/// An iterator that reads a utf8-encoded character on each iteration,
/// until `.read_char()` encounters `EndOfFile`.
///
/// # Notes about the Iteration Protocol
///
/// The `Chars` may yield `None` and thus terminate
/// an iteration, but continue to yield elements if iteration
/// is attempted again.
///
/// # Error
///
/// Any error other than `EndOfFile` that is produced by the underlying Reader
/// is returned by the iterator and should be handled by the caller.
#[cfg(not(stage0))]
pub struct Chars<'r, T:'r> { pub struct Chars<'r, T:'r> {
buffer: &'r mut T buffer: &'r mut T
} }
@ -1697,12 +1612,6 @@ pub trait Acceptor<T> {
} }
} }
/// Note: stage0-specific version that lacks bound on A.
#[cfg(stage0)]
pub struct IncomingConnections<'a, A> {
inc: &'a mut A,
}
/// An infinite iterator over incoming connection attempts. /// An infinite iterator over incoming connection attempts.
/// Calling `next` will block the task until a connection is attempted. /// Calling `next` will block the task until a connection is attempted.
/// ///
@ -1710,7 +1619,6 @@ pub struct IncomingConnections<'a, A> {
/// `Some`. The `Some` contains the `IoResult` representing whether the /// `Some`. The `Some` contains the `IoResult` representing whether the
/// connection attempt was successful. A successful connection will be wrapped /// connection attempt was successful. A successful connection will be wrapped
/// in `Ok`. A failed connection is represented as an `Err`. /// in `Ok`. A failed connection is represented as an `Err`.
#[cfg(not(stage0))]
pub struct IncomingConnections<'a, A:'a> { pub struct IncomingConnections<'a, A:'a> {
inc: &'a mut A, inc: &'a mut A,
} }

View File

@ -108,14 +108,10 @@
#![feature(macro_rules, globs, managed_boxes, linkage)] #![feature(macro_rules, globs, managed_boxes, linkage)]
#![feature(default_type_params, phase, lang_items, unsafe_destructor)] #![feature(default_type_params, phase, lang_items, unsafe_destructor)]
#![feature(import_shadowing)] #![feature(import_shadowing)]
#![feature(issue_5723_bootstrap)]
// Don't link to std. We are std. // Don't link to std. We are std.
#![no_std] #![no_std]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#![allow(deprecated)] #![allow(deprecated)]
#![deny(missing_doc)] #![deny(missing_doc)]

View File

@ -825,15 +825,7 @@ pub trait GenericPathUnsafe {
unsafe fn push_unchecked<T: BytesContainer>(&mut self, path: T); unsafe fn push_unchecked<T: BytesContainer>(&mut self, path: T);
} }
/// Note: stage0-specific version that lacks bound.
#[cfg(stage0)]
pub struct Display<'a, P> {
path: &'a P,
filename: bool
}
/// Helper struct for printing paths with format!() /// Helper struct for printing paths with format!()
#[cfg(not(stage0))]
pub struct Display<'a, P:'a> { pub struct Display<'a, P:'a> {
path: &'a P, path: &'a P,
filename: bool filename: bool

View File

@ -701,30 +701,6 @@ mod imp {
static IMAGE_FILE_MACHINE_IA64: libc::DWORD = 0x0200; static IMAGE_FILE_MACHINE_IA64: libc::DWORD = 0x0200;
static IMAGE_FILE_MACHINE_AMD64: libc::DWORD = 0x8664; static IMAGE_FILE_MACHINE_AMD64: libc::DWORD = 0x8664;
#[cfg(stage0)]
#[packed]
struct SYMBOL_INFO {
SizeOfStruct: libc::c_ulong,
TypeIndex: libc::c_ulong,
Reserved: [u64, ..2],
Index: libc::c_ulong,
Size: libc::c_ulong,
ModBase: u64,
Flags: libc::c_ulong,
Value: u64,
Address: u64,
Register: libc::c_ulong,
Scope: libc::c_ulong,
Tag: libc::c_ulong,
NameLen: libc::c_ulong,
MaxNameLen: libc::c_ulong,
// note that windows has this as 1, but it basically just means that
// the name is inline at the end of the struct. For us, we just bump
// the struct size up to MAX_SYM_NAME.
Name: [libc::c_char, ..MAX_SYM_NAME],
}
#[cfg(not(stage0))]
#[repr(C, packed)] #[repr(C, packed)]
struct SYMBOL_INFO { struct SYMBOL_INFO {
SizeOfStruct: libc::c_ulong, SizeOfStruct: libc::c_ulong,

View File

@ -386,18 +386,10 @@ pub struct Receiver<T> {
/// whenever `next` is called, waiting for a new message, and `None` will be /// whenever `next` is called, waiting for a new message, and `None` will be
/// returned when the corresponding channel has hung up. /// returned when the corresponding channel has hung up.
#[unstable] #[unstable]
#[cfg(not(stage0))]
pub struct Messages<'a, T:'a> { pub struct Messages<'a, T:'a> {
rx: &'a Receiver<T> rx: &'a Receiver<T>
} }
/// Stage0 only
#[cfg(stage0)]
#[unstable]
pub struct Messages<'a, T> {
rx: &'a Receiver<T>
}
/// The sending-half of Rust's asynchronous channel type. This half can only be /// The sending-half of Rust's asynchronous channel type. This half can only be
/// owned by one task, but it can be cloned to send to other tasks. /// owned by one task, but it can be cloned to send to other tasks.
#[unstable] #[unstable]

View File

@ -76,7 +76,6 @@ pub struct Select {
/// A handle to a receiver which is currently a member of a `Select` set of /// A handle to a receiver which is currently a member of a `Select` set of
/// receivers. This handle is used to keep the receiver in the set as well as /// receivers. This handle is used to keep the receiver in the set as well as
/// interact with the underlying receiver. /// interact with the underlying receiver.
#[cfg(not(stage0))]
pub struct Handle<'rx, T:'rx> { pub struct Handle<'rx, T:'rx> {
/// The ID of this handle, used to compare against the return value of /// The ID of this handle, used to compare against the return value of
/// `Select::wait()` /// `Select::wait()`
@ -92,23 +91,6 @@ pub struct Handle<'rx, T:'rx> {
rx: &'rx Receiver<T>, rx: &'rx Receiver<T>,
} }
/// Stage0 only
#[cfg(stage0)]
pub struct Handle<'rx, T> {
/// The ID of this handle, used to compare against the return value of
/// `Select::wait()`
id: uint,
selector: &'rx Select,
next: *mut Handle<'static, ()>,
prev: *mut Handle<'static, ()>,
added: bool,
packet: &'rx Packet+'rx,
// due to our fun transmutes, we be sure to place this at the end. (nothing
// previous relies on T)
rx: &'rx Receiver<T>,
}
struct Packets { cur: *mut Handle<'static, ()> } struct Packets { cur: *mut Handle<'static, ()> }
#[doc(hidden)] #[doc(hidden)]

View File

@ -29,13 +29,9 @@
#![feature(phase, globs, macro_rules, unsafe_destructor)] #![feature(phase, globs, macro_rules, unsafe_destructor)]
#![feature(import_shadowing)] #![feature(import_shadowing)]
#![feature(issue_5723_bootstrap)]
#![deny(missing_doc)] #![deny(missing_doc)]
#![no_std] #![no_std]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
#[phase(plugin, link)] extern crate core; #[phase(plugin, link)] extern crate core;
extern crate alloc; extern crate alloc;
extern crate collections; extern crate collections;

View File

@ -180,7 +180,6 @@ pub struct Mutex<T> {
/// An guard which is created by locking a mutex. Through this guard the /// An guard which is created by locking a mutex. Through this guard the
/// underlying data can be accessed. /// underlying data can be accessed.
#[cfg(not(stage0))]
pub struct MutexGuard<'a, T:'a> { pub struct MutexGuard<'a, T:'a> {
// FIXME #12808: strange name to try to avoid interfering with // FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref // field accesses of the contained type via Deref
@ -190,17 +189,6 @@ pub struct MutexGuard<'a, T:'a> {
pub cond: Condvar<'a>, pub cond: Condvar<'a>,
} }
/// stage0 only
#[cfg(stage0)]
pub struct MutexGuard<'a, T> {
// FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref
_data: &'a mut T,
/// Inner condition variable connected to the locked mutex that this guard
/// was created from. This can be used for atomic-unlock-and-deschedule.
pub cond: Condvar<'a>,
}
impl<T: Send> Mutex<T> { impl<T: Send> Mutex<T> {
/// Creates a new mutex to protect the user-supplied data. /// Creates a new mutex to protect the user-supplied data.
pub fn new(user_data: T) -> Mutex<T> { pub fn new(user_data: T) -> Mutex<T> {
@ -292,7 +280,6 @@ pub struct RWLock<T> {
/// A guard which is created by locking an rwlock in write mode. Through this /// A guard which is created by locking an rwlock in write mode. Through this
/// guard the underlying data can be accessed. /// guard the underlying data can be accessed.
#[cfg(not(stage0))]
pub struct RWLockWriteGuard<'a, T:'a> { pub struct RWLockWriteGuard<'a, T:'a> {
// FIXME #12808: strange name to try to avoid interfering with // FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref // field accesses of the contained type via Deref
@ -302,20 +289,8 @@ pub struct RWLockWriteGuard<'a, T:'a> {
pub cond: Condvar<'a>, pub cond: Condvar<'a>,
} }
/// stage0 only
#[cfg(stage0)]
pub struct RWLockWriteGuard<'a, T> {
// FIXME #12808: strange name to try to avoid interfering with
// field accesses of the contained type via Deref
_data: &'a mut T,
/// Inner condition variable that can be used to sleep on the write mode of
/// this rwlock.
pub cond: Condvar<'a>,
}
/// A guard which is created by locking an rwlock in read mode. Through this /// A guard which is created by locking an rwlock in read mode. Through this
/// guard the underlying data can be accessed. /// guard the underlying data can be accessed.
#[cfg(not(stage0))]
pub struct RWLockReadGuard<'a, T:'a> { pub struct RWLockReadGuard<'a, T:'a> {
// FIXME #12808: strange names to try to avoid interfering with // FIXME #12808: strange names to try to avoid interfering with
// field accesses of the contained type via Deref // field accesses of the contained type via Deref
@ -323,15 +298,6 @@ pub struct RWLockReadGuard<'a, T:'a> {
_guard: raw::RWLockReadGuard<'a>, _guard: raw::RWLockReadGuard<'a>,
} }
/// Stage0 only
#[cfg(stage0)]
pub struct RWLockReadGuard<'a, T> {
// FIXME #12808: strange names to try to avoid interfering with
// field accesses of the contained type via Deref
_data: &'a T,
_guard: raw::RWLockReadGuard<'a>,
}
impl<T: Send + Sync> RWLock<T> { impl<T: Send + Sync> RWLock<T> {
/// Create a reader/writer lock with the supplied data. /// Create a reader/writer lock with the supplied data.
pub fn new(user_data: T) -> RWLock<T> { pub fn new(user_data: T) -> RWLock<T> {

View File

@ -103,13 +103,6 @@ struct SemInner<Q> {
} }
#[must_use] #[must_use]
#[cfg(stage0)]
struct SemGuard<'a, Q> {
sem: &'a Sem<Q>,
}
#[must_use]
#[cfg(not(stage0))]
struct SemGuard<'a, Q:'a> { struct SemGuard<'a, Q:'a> {
sem: &'a Sem<Q>, sem: &'a Sem<Q>,
} }

View File

@ -68,12 +68,7 @@ impl<'a> Iterator<PathElem> for LinkedPath<'a> {
} }
} }
#[cfg(stage0)]
#[deriving(Clone)]
pub struct Values<'a, T>(pub slice::Items<'a, T>);
// HACK(eddyb) move this into libstd (value wrapper for slice::Items). // HACK(eddyb) move this into libstd (value wrapper for slice::Items).
#[cfg(not(stage0))]
#[deriving(Clone)] #[deriving(Clone)]
pub struct Values<'a, T:'a>(pub slice::Items<'a, T>); pub struct Values<'a, T:'a>(pub slice::Items<'a, T>);
@ -483,15 +478,6 @@ impl Map {
} }
} }
#[cfg(stage0)]
pub struct NodesMatchingSuffix<'a, S> {
map: &'a Map,
item_name: &'a S,
in_which: &'a [S],
idx: NodeId,
}
#[cfg(not(stage0))]
pub struct NodesMatchingSuffix<'a, S:'a> { pub struct NodesMatchingSuffix<'a, S:'a> {
map: &'a Map, map: &'a Map,
item_name: &'a S, item_name: &'a S,

View File

@ -349,14 +349,6 @@ pub trait IdVisitingOperation {
/// A visitor that applies its operation to all of the node IDs /// A visitor that applies its operation to all of the node IDs
/// in a visitable thing. /// in a visitable thing.
#[cfg(stage0)]
pub struct IdVisitor<'a, O> {
pub operation: &'a O,
pub pass_through_items: bool,
pub visited_outermost: bool,
}
#[cfg(not(stage0))]
pub struct IdVisitor<'a, O:'a> { pub struct IdVisitor<'a, O:'a> {
pub operation: &'a O, pub operation: &'a O,
pub pass_through_items: bool, pub pass_through_items: bool,

View File

@ -25,12 +25,8 @@
#![feature(macro_rules, globs, managed_boxes, default_type_params, phase)] #![feature(macro_rules, globs, managed_boxes, default_type_params, phase)]
#![feature(quote, struct_variant, unsafe_destructor, import_shadowing)] #![feature(quote, struct_variant, unsafe_destructor, import_shadowing)]
#![feature(issue_5723_bootstrap)]
#![allow(deprecated)] #![allow(deprecated)]
// NOTE(stage0, pcwalton): Remove after snapshot.
#![allow(unknown_features)]
extern crate fmt_macros; extern crate fmt_macros;
extern crate debug; extern crate debug;
#[phase(plugin, link)] extern crate log; #[phase(plugin, link)] extern crate log;

View File

@ -1,3 +1,11 @@
S 2014-08-29 6025926
freebsd-x86_64 285330b798eefcc929fc94c9d0604b6172ce3309
linux-i386 5b57ab2dc32952dc78551a955f3c1746b2d915a3
linux-x86_64 2624aeac3fe1b2359b61c1109e4708680e237ca5
macos-i386 deffce32408b023bcda84f6ce338ca3de02f406b
macos-x86_64 8ef7351e34fc1583570d752d223ddc6eb68ef27b
winnt-i386 c2dfa9a358de8cc554007addbc09e3e43d49aec6
S 2014-08-17 a86d9ad S 2014-08-17 a86d9ad
freebsd-x86_64 f49e0c8e64c8a60dc47df9965974d2a98ef70b34 freebsd-x86_64 f49e0c8e64c8a60dc47df9965974d2a98ef70b34
linux-i386 8f2c5f6a1b6504ee63de73c7a53aee1e4b07bca5 linux-i386 8f2c5f6a1b6504ee63de73c7a53aee1e4b07bca5

View File

@ -61,11 +61,6 @@ impl TyVisitor for MyVisitor {
fn visit_char(&mut self) -> bool { true } fn visit_char(&mut self) -> bool { true }
fn visit_estr_slice(&mut self) -> bool { true } fn visit_estr_slice(&mut self) -> bool { true }
// NOTE: remove after snapshot
#[cfg(stage0)]
fn visit_estr_fixed(&mut self,
_sz: uint, _sz2: uint,
_align: uint) -> bool { true }
fn visit_box(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true } fn visit_box(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }
fn visit_uniq(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true } fn visit_uniq(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }