From d15d55973946f8f582ba69b1789b5b5d35da5b2d Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Fri, 29 Aug 2014 14:33:08 -0700 Subject: [PATCH] Register new snapshots --- src/libcollections/dlist.rs | 19 ---- src/libcollections/lib.rs | 3 - src/libcollections/priority_queue.rs | 7 -- src/libcollections/ringbuf.rs | 19 ---- src/libcollections/smallintmap.rs | 18 ---- src/libcollections/treemap.rs | 102 ---------------------- src/libcollections/trie.rs | 20 ----- src/libcore/cell.rs | 20 ----- src/libcore/finally.rs | 7 -- src/libcore/intrinsics.rs | 8 -- src/libcore/iter.rs | 8 -- src/libcore/lib.rs | 2 +- src/libcore/raw.rs | 6 -- src/libcore/slice.rs | 59 ------------- src/libdebug/lib.rs | 2 +- src/libdebug/reflect.rs | 22 ----- src/libdebug/repr.rs | 17 ---- src/libfmt_macros/lib.rs | 3 - src/libgetopts/lib.rs | 3 - src/libgraphviz/lib.rs | 1 - src/libgraphviz/maybe_owned_vec.rs | 8 -- src/librand/distributions/mod.rs | 8 -- src/librand/lib.rs | 14 --- src/librbml/lib.rs | 10 +-- src/librlibc/lib.rs | 3 - src/librustc/lib.rs | 1 - src/librustc/middle/dataflow.rs | 7 -- src/librustc/middle/expr_use_visitor.rs | 8 -- src/librustc/middle/mem_categorization.rs | 6 -- src/librustc/middle/trans/_match.rs | 9 -- src/librustrt/exclusive.rs | 10 --- src/librustrt/lib.rs | 4 - src/librustrt/local_data.rs | 10 --- src/librustuv/access.rs | 7 -- src/librustuv/timeout.rs | 8 -- src/libserialize/lib.rs | 1 - src/libstd/collections/hashmap.rs | 18 ---- src/libstd/io/extensions.rs | 19 ---- src/libstd/io/mod.rs | 92 ------------------- src/libstd/lib.rs | 4 - src/libstd/path/mod.rs | 8 -- src/libstd/rt/backtrace.rs | 24 ----- src/libsync/comm/mod.rs | 8 -- src/libsync/comm/select.rs | 18 ---- src/libsync/lib.rs | 4 - src/libsync/lock.rs | 34 -------- src/libsync/raw.rs | 7 -- src/libsyntax/ast_map/mod.rs | 14 --- src/libsyntax/ast_util.rs | 8 -- src/libsyntax/lib.rs | 4 - src/snapshots.txt | 8 ++ src/test/run-pass/reflect-visit-type.rs | 5 -- 52 files changed, 11 insertions(+), 724 deletions(-) diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index 51566dc75f0..643da970364 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -49,16 +49,7 @@ struct Node { value: T, } -/// Note: stage0-specific version that lacks bound on A. -#[cfg(stage0)] -pub struct Items<'a, T> { - head: &'a Link, - tail: Rawlink>, - nelem: uint, -} - /// An iterator over references to the items of a `DList`. -#[cfg(not(stage0))] pub struct Items<'a, T:'a> { head: &'a Link, tail: Rawlink>, @@ -70,17 +61,7 @@ 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, - head: Rawlink>, - tail: Rawlink>, - 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, head: Rawlink>, diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index a98d9ddb9db..175597c77f6 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -23,9 +23,6 @@ #![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; diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs index 905078ccc3c..da8cf085218 100644 --- a/src/libcollections/priority_queue.rs +++ b/src/libcollections/priority_queue.rs @@ -515,14 +515,7 @@ impl PriorityQueue { } } -/// 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>, } diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs index a2db0027dee..c71367265db 100644 --- a/src/libcollections/ringbuf.rs +++ b/src/libcollections/ringbuf.rs @@ -293,17 +293,7 @@ impl RingBuf { } } -/// 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], -} - /// `RingBuf` iterator. -#[cfg(not(stage0))] pub struct Items<'a, T:'a> { lo: 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], - remaining2: &'a mut [Option], - nelts: uint, -} - /// `RingBuf` mutable iterator. -#[cfg(not(stage0))] pub struct MutItems<'a, T:'a> { remaining1: &'a mut [Option], remaining2: &'a mut [Option], diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs index 5ef1dd2ab22..b3b3bb1ea22 100644 --- a/src/libcollections/smallintmap.rs +++ b/src/libcollections/smallintmap.rs @@ -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> -} - /// Forward iterator over a map. -#[cfg(not(stage0))] pub struct Entries<'a, T:'a> { front: uint, back: uint, @@ -508,17 +499,8 @@ 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> -} - /// 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, diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs index 7a131993c44..80a7c6d4bad 100644 --- a/src/libcollections/treemap.rs +++ b/src/libcollections/treemap.rs @@ -668,20 +668,7 @@ impl TreeMap { } } -/// Note: stage0-specific version that lacks bound on A. -#[cfg(stage0)] -pub struct Entries<'a, K, V> { - stack: Vec<&'a TreeNode>, - // 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>). - node: *const TreeNode, - 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>, // 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 } -/// 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>, - // 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, - 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>, // 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 } -/// 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>, } @@ -1375,26 +1319,12 @@ impl TreeSet { } } -/// 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, ()> } @@ -1402,57 +1332,25 @@ pub struct RevSetItems<'a, T:'a> { /// A lazy forward iterator over a set that consumes the set while iterating. pub type MoveSetItems = iter::Map<'static, (T, ()), T, MoveEntries>; -/// 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>>, diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs index e79ec67cba0..fa8bcf94de1 100644 --- a/src/libcollections/trie.rs +++ b/src/libcollections/trie.rs @@ -857,17 +857,7 @@ fn remove(count: &mut uint, child: &mut Child, 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>, .. 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>, .. NUM_CHUNKS], length: uint, @@ -875,18 +865,8 @@ pub struct Entries<'a, T:'a> { remaining_max: uint } -/// Note: stage0-specific version that lacks bound on A. -#[cfg(stage0)] -pub struct MutEntries<'a, T> { - stack: [slice::MutItems<'a, Child>, .. 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>, .. NUM_CHUNKS], length: uint, diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 569cf98ebc8..1cad9a3f8ca 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -324,22 +324,12 @@ impl PartialEq for RefCell { /// 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 } -/// 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 -} - #[unsafe_destructor] #[unstable] 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. #[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 } -/// 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 -} - #[unsafe_destructor] #[unstable] impl<'b, T> Drop for RefMut<'b, T> { diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs index c36150eb964..9b59b410e7c 100644 --- a/src/libcore/finally.rs +++ b/src/libcore/finally.rs @@ -102,18 +102,11 @@ pub fn try_finally(mutate: &mut T, try_fn(&mut *f.mutate, drop) } -#[cfg(not(stage0))] struct Finallyalizer<'a,A:'a> { mutate: &'a mut A, dtor: |&mut A|: 'a } -#[cfg(stage0)] -struct Finallyalizer<'a,A> { - mutate: &'a mut A, - dtor: |&mut A|: 'a -} - #[unsafe_destructor] impl<'a,A> Drop for Finallyalizer<'a,A> { #[inline] diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 4ecc1b8f45f..9636ce6a736 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -93,9 +93,6 @@ pub trait TyVisitor { fn visit_char(&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_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_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, inner: *const TyDesc) -> bool; diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index f8a56b3d6fc..da7f026aed4 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -777,18 +777,10 @@ impl + RandomAccessIterator> RandomAccessIterato /// A mutable reference to an iterator #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] -#[cfg(not(stage0))] pub struct ByRef<'a, T:'a> { 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> Iterator for ByRef<'a, T> { #[inline] fn next(&mut self) -> Option { self.iter.next() } diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 050e2348111..7e2ea492d4c 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -58,7 +58,7 @@ #![no_std] #![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)] -#![feature(simd, unsafe_destructor, issue_5723_bootstrap)] +#![feature(simd, unsafe_destructor)] #![deny(missing_doc)] mod macros; diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 5daa693c774..188ef2a3b88 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -51,12 +51,6 @@ pub struct Procedure { /// /// This struct does not have a `Repr` implementation /// 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 data: *mut (), pub vtable: *mut (), diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 5a70cd8c847..5070a3973d1 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -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 /// match a predicate function. -#[cfg(not(stage0))] #[experimental = "needs review"] pub struct Splits<'a, T:'a> { v: &'a [T], @@ -1133,14 +1132,6 @@ pub struct Splits<'a, T:'a> { finished: bool } -/// Dox. -#[cfg(stage0)] -pub struct Splits<'a, T> { - v: &'a [T], - pred: |t: &T|: 'a -> bool, - finished: bool -} - #[experimental = "needs review"] impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> { #[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 /// by elements that match `pred`. -#[cfg(not(stage0))] #[experimental = "needs review"] pub struct MutSplits<'a, T:'a> { v: &'a mut [T], @@ -1200,14 +1190,6 @@ pub struct MutSplits<'a, T:'a> { finished: bool } -/// Dox -#[cfg(stage0)] -pub struct MutSplits<'a, T> { - v: &'a mut [T], - pred: |t: &T|: 'a -> bool, - finished: bool -} - #[experimental = "needs review"] impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> { #[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 /// match a predicate function, splitting at most a fixed number of times. -#[cfg(not(stage0))] #[experimental = "needs review"] pub struct SplitsN<'a, T:'a> { iter: Splits<'a, T>, @@ -1278,14 +1259,6 @@ pub struct SplitsN<'a, T:'a> { invert: bool } -/// Dox. -#[cfg(stage0)] -pub struct SplitsN<'a, T> { - iter: Splits<'a, T>, - count: uint, - invert: bool -} - #[experimental = "needs review"] impl<'a, T> Iterator<&'a [T]> for SplitsN<'a, T> { #[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 /// 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)] #[experimental = "needs review"] 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, /// the last slice of the iteration will be the remainder. -#[cfg(stage0)] #[deriving(Clone)] #[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> { v: &'a [T], 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 /// the vector len is not evenly divided by the chunk size, the last slice of the iteration will be /// the remainder. -#[cfg(not(stage0))] #[experimental = "needs review"] pub struct MutChunks<'a, T:'a> { v: &'a mut [T], chunk_size: uint } -/// Dox. -#[cfg(stage0)] -pub struct MutChunks<'a, T> { - v: &'a mut [T], - chunk_size: uint -} - #[experimental = "needs review"] impl<'a, T> Iterator<&'a mut [T]> for MutChunks<'a, T> { #[inline] diff --git a/src/libdebug/lib.rs b/src/libdebug/lib.rs index cc97eeffe7a..6341a380563 100644 --- a/src/libdebug/lib.rs +++ b/src/libdebug/lib.rs @@ -25,7 +25,7 @@ html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/master/")] #![experimental] -#![feature(managed_boxes, macro_rules, issue_5723_bootstrap)] +#![feature(managed_boxes, macro_rules)] #![allow(experimental)] pub mod fmt; diff --git a/src/libdebug/reflect.rs b/src/libdebug/reflect.rs index b89ea4d373d..80d0f8a8794 100644 --- a/src/libdebug/reflect.rs +++ b/src/libdebug/reflect.rs @@ -193,17 +193,6 @@ impl TyVisitor for MovePtrAdaptor { 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 { self.align_to::>(); if ! self.inner.visit_box(mtbl, inner) { return false; } @@ -239,17 +228,6 @@ impl TyVisitor for MovePtrAdaptor { 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, inner: *const TyDesc) -> bool { self.align(align); diff --git a/src/libdebug/repr.rs b/src/libdebug/repr.rs index dbd2c09497b..1f66d0352da 100644 --- a/src/libdebug/repr.rs +++ b/src/libdebug/repr.rs @@ -274,12 +274,6 @@ impl<'a> TyVisitor for ReprVisitor<'a> { 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 { try!(self, self.writer.write("box(GC) ".as_bytes())); 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, inner: *const TyDesc) -> bool { let assumed_size = if sz == 0 { n } else { sz }; diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index cef258fac20..560681765cd 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -21,9 +21,6 @@ #![crate_type = "dylib"] #![feature(macro_rules, globs, import_shadowing)] -// NOTE(stage0, pcwalton): Remove after snapshot. -#![allow(unknown_features)] - use std::char; use std::str; diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 475dd2c6743..3ffd39a0065 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -91,9 +91,6 @@ #![feature(import_shadowing)] #![deny(missing_doc)] -// NOTE(stage0, pcwalton): Remove after snapshot. -#![allow(unknown_features)] - #[cfg(test)] extern crate debug; #[cfg(test)] #[phase(plugin, link)] extern crate log; diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 10cc7e8afe9..d8325e05cdf 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -271,7 +271,6 @@ pub fn main() { #![crate_type = "rlib"] #![crate_type = "dylib"] #![license = "MIT/ASL2"] -#![feature(issue_5723_bootstrap)] #![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_root_url = "http://doc.rust-lang.org/master/")] diff --git a/src/libgraphviz/maybe_owned_vec.rs b/src/libgraphviz/maybe_owned_vec.rs index 17c75b76bc1..ab06f327592 100644 --- a/src/libgraphviz/maybe_owned_vec.rs +++ b/src/libgraphviz/maybe_owned_vec.rs @@ -34,19 +34,11 @@ use std::slice; /// 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 /// off ownership, via `Growable`. -#[cfg(not(stage0))] pub enum MaybeOwnedVector<'a,T:'a> { Growable(Vec), Borrowed(&'a [T]), } -/// Stage0 only. -#[cfg(stage0)] -pub enum MaybeOwnedVector<'a,T> { - Growable(Vec), - Borrowed(&'a [T]), -} - /// Trait for moving into a `MaybeOwnedVector` pub trait IntoMaybeOwnedVector<'a,T> { /// Moves self into a `MaybeOwnedVector` diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 447e3eea061..d15c65799f4 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -79,13 +79,6 @@ pub struct Weighted { pub item: T, } -/// Note: stage0-specific version that lacks bound on A. -#[cfg(stage0)] -pub struct WeightedChoice<'a, T> { - items: &'a mut [Weighted], - weight_range: Range -} - /// A distribution that selects from a finite collection of weighted items. /// /// 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)); /// } /// ``` -#[cfg(not(stage0))] pub struct WeightedChoice<'a, T:'a> { items: &'a mut [Weighted], weight_range: Range diff --git a/src/librand/lib.rs b/src/librand/lib.rs index f1ed9ae8997..52112380c60 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -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. /// /// This iterator is created via the `gen_iter` method on `Rng`. -#[cfg(not(stage0))] pub struct Generator<'a, T, R:'a> { rng: &'a mut R, } @@ -289,16 +282,9 @@ impl<'a, T: Rand, R: Rng> Iterator 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. /// /// This iterator is created via the `gen_ascii_chars` method on `Rng`. -#[cfg(not(stage0))] pub struct AsciiGenerator<'a, R:'a> { rng: &'a mut R, } diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index a05c877a6a6..38021568ee5 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -24,7 +24,7 @@ html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://doc.rust-lang.org/master/", html_playground_url = "http://play.rust-lang.org/")] -#![feature(macro_rules, phase, issue_5723_bootstrap)] +#![feature(macro_rules, phase)] #![allow(missing_doc)] extern crate serialize; @@ -662,14 +662,6 @@ pub mod writer { pub type EncodeResult = io::IoResult<()>; // rbml writing - #[cfg(stage0)] - pub struct Encoder<'a, W> { - pub writer: &'a mut W, - size_positions: Vec, - } - - // rbml writing - #[cfg(not(stage0))] pub struct Encoder<'a, W:'a> { pub writer: &'a mut W, size_positions: Vec, diff --git a/src/librlibc/lib.rs b/src/librlibc/lib.rs index 739ec2cf43f..d51d5a0aef2 100644 --- a/src/librlibc/lib.rs +++ b/src/librlibc/lib.rs @@ -35,9 +35,6 @@ // LLVM to optimize these function calls to themselves! #![no_builtins] -// NOTE(stage0, pcwalton): Remove after snapshot. -#![allow(unknown_features)] - #[cfg(test)] extern crate native; #[cfg(test)] extern crate test; #[cfg(test)] extern crate debug; diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 9b3cc2b6a0a..239e858eeeb 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -31,7 +31,6 @@ This API is completely unstable and subject to change. #![allow(deprecated)] #![feature(macro_rules, globs, struct_variant, managed_boxes, quote)] #![feature(default_type_params, phase, unsafe_destructor)] -#![feature(issue_5723_bootstrap)] #![allow(unknown_features)] // NOTE: Remove after next snapshot #![feature(rustc_diagnostic_macros)] diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 91c227cd5bc..aaa30c3b40c 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -80,13 +80,6 @@ pub trait DataFlowOperator : BitwiseOperator { 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> { dfcx: &'a mut DataFlowContext<'b, O>, changed: bool diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index ae9a3fa6a67..aabcadb6c34 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -192,14 +192,6 @@ impl OverloadedCallType { // supplies types from the tree. After type checking is complete, you // 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> { typer: &'t TYPER, mc: mc::MemCategorizationContext<'t,TYPER>, diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 662b55ba361..23cab419aa2 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -240,12 +240,6 @@ impl ast_node for ast::Pat { 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> { typer: &'t TYPER } diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs index bbd6c252849..9531e824298 100644 --- a/src/librustc/middle/trans/_match.rs +++ b/src/librustc/middle/trans/_match.rs @@ -340,21 +340,12 @@ struct ArmData<'a, 'b> { * 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. */ -#[cfg(not(stage0))] struct Match<'a, 'b:'a> { pats: Vec>, data: &'a ArmData<'a, 'b>, bound_ptrs: Vec<(Ident, ValueRef)> } -///Dox -#[cfg(stage0)] -struct Match<'a, 'b> { - pats: Vec>, - data: &'a ArmData<'a, 'b>, - bound_ptrs: Vec<(Ident, ValueRef)> -} - impl<'a, 'b> Repr for Match<'a, 'b> { fn repr(&self, tcx: &ty::ctxt) -> String { if tcx.sess.verbose() { diff --git a/src/librustrt/exclusive.rs b/src/librustrt/exclusive.rs index 28514bec5b4..e5de2d195eb 100644 --- a/src/librustrt/exclusive.rs +++ b/src/librustrt/exclusive.rs @@ -26,17 +26,7 @@ pub struct Exclusive { data: UnsafeCell, } -/// 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` -#[cfg(not(stage0))] pub struct ExclusiveGuard<'a, T:'a> { // FIXME #12808: strange name to try to avoid interfering with // field accesses of the contained type via Deref diff --git a/src/librustrt/lib.rs b/src/librustrt/lib.rs index 5ca46a728c3..594e50d9913 100644 --- a/src/librustrt/lib.rs +++ b/src/librustrt/lib.rs @@ -19,13 +19,9 @@ #![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)] #![feature(linkage, lang_items, unsafe_destructor, default_type_params)] #![feature(import_shadowing)] -#![feature(issue_5723_bootstrap)] #![no_std] #![experimental] -// NOTE(stage0, pcwalton): Remove after snapshot. -#![allow(unknown_features)] - #[phase(plugin, link)] extern crate core; extern crate alloc; extern crate libc; diff --git a/src/librustrt/local_data.rs b/src/librustrt/local_data.rs index fedea3c31e0..a68cf3f8756 100644 --- a/src/librustrt/local_data.rs +++ b/src/librustrt/local_data.rs @@ -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 /// structure is dropped it will return the borrow on the data. -#[cfg(not(stage0))] pub struct Ref { // FIXME #12808: strange names to try to avoid interfering with // field accesses of the contained type via Deref @@ -152,15 +151,6 @@ pub struct Ref { _marker: marker::NoSend } -/// stage0 only -#[cfg(stage0)] -pub struct Ref { - // FIXME #12808: strange names to try to avoid interfering with - // field accesses of the contained type via Deref - _inner: &'static TLDValueBox, - _marker: marker::NoSend -} - fn key_to_key_value(key: Key) -> uint { key as *const _ as uint } diff --git a/src/librustuv/access.rs b/src/librustuv/access.rs index 0fa89ce989a..664c9425007 100644 --- a/src/librustuv/access.rs +++ b/src/librustuv/access.rs @@ -26,13 +26,6 @@ pub struct Access { inner: Arc>>, } -#[cfg(stage0)] -pub struct Guard<'a, T> { - access: &'a mut Access, - missile: Option, -} - -#[cfg(not(stage0))] pub struct Guard<'a, T:'static> { access: &'a mut Access, missile: Option, diff --git a/src/librustuv/timeout.rs b/src/librustuv/timeout.rs index 6b550288f67..88267c0ac45 100644 --- a/src/librustuv/timeout.rs +++ b/src/librustuv/timeout.rs @@ -28,14 +28,6 @@ pub struct AccessTimeout { pub access: access::Access, } -#[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> { state: &'a mut TimeoutState, pub access: access::Guard<'a, T>, diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index 44ea56f4c73..5c35ad85233 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -24,7 +24,6 @@ Core encoding and decoding interfaces. html_root_url = "http://doc.rust-lang.org/master/", html_playground_url = "http://play.rust-lang.org/")] #![feature(macro_rules, managed_boxes, default_type_params, phase)] -#![feature(issue_5723_bootstrap)] // test harness access #[cfg(test)] diff --git a/src/libstd/collections/hashmap.rs b/src/libstd/collections/hashmap.rs index 714712d9eba..1985128c4e3 100644 --- a/src/libstd/collections/hashmap.rs +++ b/src/libstd/collections/hashmap.rs @@ -409,32 +409,14 @@ mod table { assert_eq!(size_of::(), size_of::()) } - /// Note: stage0-specific version that lacks bound. - #[cfg(stage0)] - pub struct Entries<'a, K, V> { - table: &'a RawTable, - idx: uint, - elems_seen: uint, - } - /// Iterator over shared references to entries in a table. - #[cfg(not(stage0))] pub struct Entries<'a, K:'a, V:'a> { table: &'a RawTable, idx: uint, elems_seen: uint, } - /// Note: stage0-specific version that lacks bound. - #[cfg(stage0)] - pub struct MutEntries<'a, K, V> { - table: &'a mut RawTable, - idx: uint, - elems_seen: uint, - } - /// Iterator over mutable references to entries in a table. - #[cfg(not(stage0))] pub struct MutEntries<'a, K:'a, V:'a> { table: &'a mut RawTable, idx: uint, diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index ffbcdd87bfe..b61e7c6b441 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -37,25 +37,6 @@ use ptr::RawPtr; /// /// 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(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> { reader: &'r mut T, } diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 38aa58f1c6a..905012b7bf3 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -976,13 +976,6 @@ unsafe fn slice_vec_capacity<'a, T>(v: &'a mut Vec, 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 /// 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> { /// The underlying reader which this is referencing inner: &'a mut R @@ -1066,16 +1058,8 @@ pub trait Writer { /// /// This function will return any I/O error reported while formatting. 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 // off I/O errors. instead of discarding them - #[cfg(not(stage0))] struct Adaptor<'a, T:'a> { inner: &'a mut T, error: IoResult<()>, @@ -1335,37 +1319,6 @@ impl<'a> Writer for &'a mut Writer+'a { /// 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: 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> { /// The underlying writer which this is referencing inner: &'a mut W @@ -1399,25 +1352,6 @@ impl Stream for T {} /// /// 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(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> { buffer: &'r mut T, } @@ -1445,25 +1379,6 @@ impl<'r, T: Buffer> Iterator> for Lines<'r, T> { /// /// 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(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> { buffer: &'r mut T } @@ -1697,12 +1612,6 @@ pub trait Acceptor { } } -/// 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. /// 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 /// connection attempt was successful. A successful connection will be wrapped /// in `Ok`. A failed connection is represented as an `Err`. -#[cfg(not(stage0))] pub struct IncomingConnections<'a, A:'a> { inc: &'a mut A, } diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 8c1ed7cfa8f..7fed4c94164 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -108,14 +108,10 @@ #![feature(macro_rules, globs, managed_boxes, linkage)] #![feature(default_type_params, phase, lang_items, unsafe_destructor)] #![feature(import_shadowing)] -#![feature(issue_5723_bootstrap)] // Don't link to std. We are std. #![no_std] -// NOTE(stage0, pcwalton): Remove after snapshot. -#![allow(unknown_features)] - #![allow(deprecated)] #![deny(missing_doc)] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 6a10be84a62..86036c2a2dc 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -825,15 +825,7 @@ pub trait GenericPathUnsafe { unsafe fn push_unchecked(&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!() -#[cfg(not(stage0))] pub struct Display<'a, P:'a> { path: &'a P, filename: bool diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs index 58b3179a297..0c216798175 100644 --- a/src/libstd/rt/backtrace.rs +++ b/src/libstd/rt/backtrace.rs @@ -701,30 +701,6 @@ mod imp { static IMAGE_FILE_MACHINE_IA64: libc::DWORD = 0x0200; 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)] struct SYMBOL_INFO { SizeOfStruct: libc::c_ulong, diff --git a/src/libsync/comm/mod.rs b/src/libsync/comm/mod.rs index 16f6eea6144..c8b86c47c90 100644 --- a/src/libsync/comm/mod.rs +++ b/src/libsync/comm/mod.rs @@ -386,18 +386,10 @@ pub struct Receiver { /// whenever `next` is called, waiting for a new message, and `None` will be /// returned when the corresponding channel has hung up. #[unstable] -#[cfg(not(stage0))] pub struct Messages<'a, T:'a> { rx: &'a Receiver } -/// Stage0 only -#[cfg(stage0)] -#[unstable] -pub struct Messages<'a, T> { - rx: &'a Receiver -} - /// 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. #[unstable] diff --git a/src/libsync/comm/select.rs b/src/libsync/comm/select.rs index dc9891dd1ee..669c1c958b8 100644 --- a/src/libsync/comm/select.rs +++ b/src/libsync/comm/select.rs @@ -76,7 +76,6 @@ pub struct Select { /// 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 /// interact with the underlying receiver. -#[cfg(not(stage0))] pub struct Handle<'rx, T:'rx> { /// The ID of this handle, used to compare against the return value of /// `Select::wait()` @@ -92,23 +91,6 @@ pub struct Handle<'rx, T:'rx> { rx: &'rx Receiver, } -/// 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, -} - struct Packets { cur: *mut Handle<'static, ()> } #[doc(hidden)] diff --git a/src/libsync/lib.rs b/src/libsync/lib.rs index c2744751ee5..e0acce1cd94 100644 --- a/src/libsync/lib.rs +++ b/src/libsync/lib.rs @@ -29,13 +29,9 @@ #![feature(phase, globs, macro_rules, unsafe_destructor)] #![feature(import_shadowing)] -#![feature(issue_5723_bootstrap)] #![deny(missing_doc)] #![no_std] -// NOTE(stage0, pcwalton): Remove after snapshot. -#![allow(unknown_features)] - #[phase(plugin, link)] extern crate core; extern crate alloc; extern crate collections; diff --git a/src/libsync/lock.rs b/src/libsync/lock.rs index e1cae6c62d5..08421d24fbb 100644 --- a/src/libsync/lock.rs +++ b/src/libsync/lock.rs @@ -180,7 +180,6 @@ pub struct Mutex { /// An guard which is created by locking a mutex. Through this guard the /// underlying data can be accessed. -#[cfg(not(stage0))] pub struct MutexGuard<'a, T:'a> { // FIXME #12808: strange name to try to avoid interfering with // field accesses of the contained type via Deref @@ -190,17 +189,6 @@ pub struct MutexGuard<'a, T:'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 Mutex { /// Creates a new mutex to protect the user-supplied data. pub fn new(user_data: T) -> Mutex { @@ -292,7 +280,6 @@ pub struct RWLock { /// A guard which is created by locking an rwlock in write mode. Through this /// guard the underlying data can be accessed. -#[cfg(not(stage0))] pub struct RWLockWriteGuard<'a, T:'a> { // FIXME #12808: strange name to try to avoid interfering with // field accesses of the contained type via Deref @@ -302,20 +289,8 @@ pub struct RWLockWriteGuard<'a, T:'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 /// guard the underlying data can be accessed. -#[cfg(not(stage0))] pub struct RWLockReadGuard<'a, T:'a> { // FIXME #12808: strange names to try to avoid interfering with // field accesses of the contained type via Deref @@ -323,15 +298,6 @@ pub struct RWLockReadGuard<'a, T:'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 RWLock { /// Create a reader/writer lock with the supplied data. pub fn new(user_data: T) -> RWLock { diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs index 245a7666a64..b259eb7e579 100644 --- a/src/libsync/raw.rs +++ b/src/libsync/raw.rs @@ -103,13 +103,6 @@ struct SemInner { } #[must_use] -#[cfg(stage0)] -struct SemGuard<'a, Q> { - sem: &'a Sem, -} - -#[must_use] -#[cfg(not(stage0))] struct SemGuard<'a, Q:'a> { sem: &'a Sem, } diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs index 993c5ce676a..d1f78c71e19 100644 --- a/src/libsyntax/ast_map/mod.rs +++ b/src/libsyntax/ast_map/mod.rs @@ -68,12 +68,7 @@ impl<'a> Iterator 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). -#[cfg(not(stage0))] #[deriving(Clone)] 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> { map: &'a Map, item_name: &'a S, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index cc586a3affa..8ef13ef2604 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -349,14 +349,6 @@ pub trait IdVisitingOperation { /// A visitor that applies its operation to all of the node IDs /// 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 operation: &'a O, pub pass_through_items: bool, diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 9bbd6b2a36e..254428486f8 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -25,12 +25,8 @@ #![feature(macro_rules, globs, managed_boxes, default_type_params, phase)] #![feature(quote, struct_variant, unsafe_destructor, import_shadowing)] -#![feature(issue_5723_bootstrap)] #![allow(deprecated)] -// NOTE(stage0, pcwalton): Remove after snapshot. -#![allow(unknown_features)] - extern crate fmt_macros; extern crate debug; #[phase(plugin, link)] extern crate log; diff --git a/src/snapshots.txt b/src/snapshots.txt index f34f1c1371f..9fcaa30cf5f 100644 --- a/src/snapshots.txt +++ b/src/snapshots.txt @@ -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 freebsd-x86_64 f49e0c8e64c8a60dc47df9965974d2a98ef70b34 linux-i386 8f2c5f6a1b6504ee63de73c7a53aee1e4b07bca5 diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs index f599a2b7ad5..e17f1409944 100644 --- a/src/test/run-pass/reflect-visit-type.rs +++ b/src/test/run-pass/reflect-visit-type.rs @@ -61,11 +61,6 @@ impl TyVisitor for MyVisitor { fn visit_char(&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_uniq(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }