From 7e2ffc7090a70fe8c77a0e03fcec3cb1387141f2 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Mon, 16 Nov 2015 19:54:28 +0300 Subject: [PATCH] Add missing annotations and some tests --- src/liballoc/arc.rs | 7 ++++ src/liballoc/boxed.rs | 22 +++++++++++ src/liballoc/rc.rs | 7 ++++ src/libcollections/binary_heap.rs | 2 + src/libcollections/borrow.rs | 1 + src/libcollections/btree/node.rs | 1 - src/libcollections/fmt.rs | 8 ++++ src/libcollections/lib.rs | 2 + src/libcollections/linked_list.rs | 2 + src/libcollections/slice.rs | 9 +++++ src/libcollections/str.rs | 14 +++++++ src/libcollections/string.rs | 9 +++++ src/libcollections/vec.rs | 6 +++ src/libcollections/vec_deque.rs | 3 ++ src/libcore/any.rs | 1 + src/libcore/cell.rs | 1 + src/libcore/char.rs | 3 ++ src/libcore/fmt/mod.rs | 8 +++- src/libcore/fmt/num.rs | 1 + src/libcore/hash/mod.rs | 1 + src/libcore/iter.rs | 10 +++++ src/libcore/marker.rs | 19 ++++++++++ src/libcore/num/f32.rs | 3 ++ src/libcore/num/f64.rs | 3 ++ src/libcore/num/mod.rs | 13 +++++++ src/libcore/ops.rs | 19 ++++++++++ src/libcore/prelude/v1.rs | 14 +++++++ src/libcore/ptr.rs | 1 + src/libcore/result.rs | 1 + src/libcore/slice.rs | 7 ++++ src/libcore/str/mod.rs | 3 ++ src/libcore/sync/atomic.rs | 9 +++++ src/libcore/tuple.rs | 2 - src/librustc_unicode/char.rs | 2 + src/libstd/collections/hash/map.rs | 4 ++ src/libstd/collections/hash/set.rs | 5 +++ src/libstd/collections/mod.rs | 10 ++++- src/libstd/fs.rs | 2 + src/libstd/io/buffered.rs | 1 + src/libstd/io/mod.rs | 8 ++++ src/libstd/io/prelude.rs | 2 + src/libstd/lib.rs | 37 +++++++++++++++++++ src/libstd/macros.rs | 14 +++++++ src/libstd/net/addr.rs | 1 + src/libstd/net/mod.rs | 5 +++ src/libstd/net/tcp.rs | 2 + src/libstd/net/udp.rs | 1 + src/libstd/num/f32.rs | 5 +++ src/libstd/num/f64.rs | 5 +++ src/libstd/num/mod.rs | 3 ++ src/libstd/os/linux/mod.rs | 3 +- src/libstd/os/linux/raw.rs | 1 + src/libstd/os/mod.rs | 8 +++- src/libstd/sync/barrier.rs | 1 + src/libstd/sync/mod.rs | 11 ++++++ src/libstd/sync/mpsc/mod.rs | 6 +++ src/libstd/sync/mpsc/mpsc_queue.rs | 1 - src/libstd/sync/mutex.rs | 4 +- src/libstd/sync/rwlock.rs | 4 ++ src/libstd/sys/common/poison.rs | 3 ++ src/libstd/sys/common/unwind/mod.rs | 6 +++ src/libstd/sys/common/wtf8.rs | 2 + src/libstd/sys/unix/ext/fs.rs | 4 ++ src/libstd/sys/unix/ext/mod.rs | 6 +-- src/libstd/sys/unix/ext/process.rs | 3 ++ src/libstd/sys/unix/ext/raw.rs | 2 + src/libstd/sys/unix/time.rs | 1 + src/libstd/sys/windows/ext/ffi.rs | 1 + src/libstd/sys/windows/ext/fs.rs | 3 ++ src/libstd/sys/windows/ext/mod.rs | 6 +-- src/libstd/sys/windows/ext/process.rs | 4 ++ src/libstd/sys/windows/time.rs | 1 + src/libstd/thread/mod.rs | 2 + src/libstd/thread/scoped_tls.rs | 9 ++++- src/libstd/time/duration.rs | 4 ++ src/libstd/time/mod.rs | 1 + src/test/auxiliary/inherited_stability.rs | 2 + src/test/auxiliary/internal_unstable.rs | 10 +++++ src/test/auxiliary/lint_stability.rs | 4 ++ src/test/compile-fail/issue-17337.rs | 2 + .../compile-fail/lint-stability-fields.rs | 2 + src/test/compile-fail/lint-stability.rs | 10 +++-- src/test/compile-fail/missing-stability.rs | 2 + .../stability-attribute-sanity-2.rs | 7 ++++ .../stability-attribute-sanity.rs | 2 + src/test/rustdoc/issue-18199.rs | 1 + src/test/rustdoc/issue-27759.rs | 2 + 87 files changed, 439 insertions(+), 21 deletions(-) diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 8205e13205ff8..7863f1018116a 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -130,10 +130,13 @@ pub struct Arc { _ptr: Shared>, } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Arc { } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for Arc { } #[cfg(not(stage0))] // remove cfg after new snapshot +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized> for Arc {} /// A weak pointer to an `Arc`. @@ -148,10 +151,13 @@ pub struct Weak { _ptr: Shared>, } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Weak { } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for Weak { } #[cfg(not(stage0))] // remove cfg after new snapshot +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized> for Weak {} #[stable(feature = "rust1", since = "1.0.0")] @@ -1157,6 +1163,7 @@ mod tests { } } +#[stable(feature = "rust1", since = "1.0.0")] impl borrow::Borrow for Arc { fn borrow(&self) -> &T { &**self diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index b5c6cdff119d6..65c66ebe768f5 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -136,6 +136,9 @@ pub struct IntermediateBox { marker: marker::PhantomData<*mut T>, } +#[unstable(feature = "placement_in", + reason = "placement box design is still being worked out.", + issue = "27779")] impl Place for IntermediateBox { fn pointer(&mut self) -> *mut T { self.ptr as *mut T @@ -170,12 +173,18 @@ fn make_place() -> IntermediateBox { } } +#[unstable(feature = "placement_in", + reason = "placement box design is still being worked out.", + issue = "27779")] impl BoxPlace for IntermediateBox { fn make_place() -> IntermediateBox { make_place() } } +#[unstable(feature = "placement_in", + reason = "placement box design is still being worked out.", + issue = "27779")] impl InPlace for IntermediateBox { type Owner = Box; unsafe fn finalize(self) -> Box { @@ -183,6 +192,7 @@ impl InPlace for IntermediateBox { } } +#[unstable(feature = "placement_new_protocol", issue = "27779")] impl Boxed for Box { type Data = T; type Place = IntermediateBox; @@ -191,6 +201,9 @@ impl Boxed for Box { } } +#[unstable(feature = "placement_in", + reason = "placement box design is still being worked out.", + issue = "27779")] impl Placer for ExchangeHeapSingleton { type Place = IntermediateBox; @@ -199,6 +212,9 @@ impl Placer for ExchangeHeapSingleton { } } +#[unstable(feature = "placement_in", + reason = "placement box design is still being worked out.", + issue = "27779")] impl Drop for IntermediateBox { fn drop(&mut self) { if self.size > 0 { @@ -518,6 +534,7 @@ pub trait FnBox { fn call_box(self: Box, args: A) -> Self::Output; } +#[unstable(feature = "fnbox", reason = "Newly introduced", issue = "0")] impl FnBox for F where F: FnOnce { @@ -528,6 +545,7 @@ impl FnBox for F } } +#[unstable(feature = "fnbox", reason = "Newly introduced", issue = "0")] impl<'a,A,R> FnOnce for Box+'a> { type Output = R; @@ -536,6 +554,7 @@ impl<'a,A,R> FnOnce for Box+'a> { } } +#[unstable(feature = "fnbox", reason = "Newly introduced", issue = "0")] impl<'a,A,R> FnOnce for Box+Send+'a> { type Output = R; @@ -544,6 +563,7 @@ impl<'a,A,R> FnOnce for Box+Send+'a> { } } +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized> for Box {} #[stable(feature = "box_slice_clone", since = "1.3.0")] @@ -597,12 +617,14 @@ impl Clone for Box<[T]> { } } +#[stable(feature = "rust1", since = "1.0.0")] impl borrow::Borrow for Box { fn borrow(&self) -> &T { &**self } } +#[stable(feature = "rust1", since = "1.0.0")] impl borrow::BorrowMut for Box { fn borrow_mut(&mut self) -> &mut T { &mut **self diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 88db3cfe4b612..7abdc447ee556 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -191,10 +191,13 @@ pub struct Rc { _ptr: Shared>, } +#[stable(feature = "rust1", since = "1.0.0")] impl !marker::Send for Rc {} +#[stable(feature = "rust1", since = "1.0.0")] impl !marker::Sync for Rc {} #[cfg(not(stage0))] // remove cfg after new snapshot +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized> for Rc {} impl Rc { @@ -723,10 +726,13 @@ pub struct Weak { _ptr: Shared>, } +#[stable(feature = "rust1", since = "1.0.0")] impl !marker::Send for Weak {} +#[stable(feature = "rust1", since = "1.0.0")] impl !marker::Sync for Weak {} #[cfg(not(stage0))] // remove cfg after new snapshot +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized> for Weak {} impl Weak { @@ -1126,6 +1132,7 @@ mod tests { } } +#[stable(feature = "rust1", since = "1.0.0")] impl borrow::Borrow for Rc { fn borrow(&self) -> &T { &**self diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index 57646bef124c8..db555fe61aa37 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -731,6 +731,7 @@ impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> { #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {} +#[stable(feature = "rust1", since = "1.0.0")] impl From> for BinaryHeap { fn from(vec: Vec) -> BinaryHeap { let mut heap = BinaryHeap { data: vec }; @@ -743,6 +744,7 @@ impl From> for BinaryHeap { } } +#[stable(feature = "rust1", since = "1.0.0")] impl From> for Vec { fn from(heap: BinaryHeap) -> Vec { heap.data diff --git a/src/libcollections/borrow.rs b/src/libcollections/borrow.rs index 9b8f8c8f5bb84..c26b42d016a81 100644 --- a/src/libcollections/borrow.rs +++ b/src/libcollections/borrow.rs @@ -24,6 +24,7 @@ use fmt; use self::Cow::*; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::borrow::{Borrow, BorrowMut}; #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs index 4380f315ee7f1..dc4b7a1c3f7f3 100644 --- a/src/libcollections/btree/node.rs +++ b/src/libcollections/btree/node.rs @@ -451,7 +451,6 @@ impl Node { } // FIXME(gereeter) Write an efficient clone_from -#[stable(feature = "rust1", since = "1.0.0")] impl Clone for Node { fn clone(&self) -> Node { let mut ret = if self.is_leaf() { diff --git a/src/libcollections/fmt.rs b/src/libcollections/fmt.rs index 990575ebbb336..ebc2de4be7a2c 100644 --- a/src/libcollections/fmt.rs +++ b/src/libcollections/fmt.rs @@ -475,13 +475,21 @@ #![stable(feature = "rust1", since = "1.0.0")] +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{Formatter, Result, Write, rt}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{Octal, Binary}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{Display, Debug}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{LowerHex, UpperHex, Pointer}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{LowerExp, UpperExp}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::Error; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{ArgumentV1, Arguments, write, radix, Radix, RadixFmt}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple}; use string; diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 54b98c6e17992..dfdf36e6f605b 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -107,11 +107,13 @@ pub mod vec_deque; #[stable(feature = "rust1", since = "1.0.0")] pub mod btree_map { + #[stable(feature = "rust1", since = "1.0.0")] pub use btree::map::*; } #[stable(feature = "rust1", since = "1.0.0")] pub mod btree_set { + #[stable(feature = "rust1", since = "1.0.0")] pub use btree::set::*; } diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs index 8e6b0183d53d2..a689c66eeaff5 100644 --- a/src/libcollections/linked_list.rs +++ b/src/libcollections/linked_list.rs @@ -857,6 +857,7 @@ impl DoubleEndedIterator for IntoIter { fn next_back(&mut self) -> Option { self.list.pop_back() } } +#[stable(feature = "rust1", since = "1.0.0")] impl ExactSizeIterator for IntoIter {} #[stable(feature = "rust1", since = "1.0.0")] @@ -890,6 +891,7 @@ impl<'a, T> IntoIterator for &'a LinkedList { } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> IntoIterator for &'a mut LinkedList { type Item = &'a mut T; type IntoIter = IterMut<'a, T>; diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 25ff1f1a82aac..ec8881279831a 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -102,12 +102,18 @@ use core::slice as core_slice; use borrow::{Borrow, BorrowMut, ToOwned}; use vec::Vec; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{Chunks, Windows}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{Iter, IterMut}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{SplitMut, ChunksMut, Split}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut}; +#[unstable(feature = "ref_slice", issue = "27774")] #[allow(deprecated)] pub use core::slice::{bytes, mut_ref_slice, ref_slice}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{from_raw_parts, from_raw_parts_mut}; //////////////////////////////////////////////////////////////////////////////// @@ -860,6 +866,9 @@ pub trait SliceConcatExt { fn connect(&self, sep: &T) -> Self::Output; } +#[unstable(feature = "slice_concat_ext", + reason = "trait should not have to exist", + issue = "27747")] impl> SliceConcatExt for [V] { type Output = Vec; diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index a5013f4e75b18..c16ce61a1365a 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -37,19 +37,33 @@ use vec::Vec; use slice::SliceConcatExt; use boxed::Box; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{FromStr, Utf8Error}; #[allow(deprecated)] +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{Lines, LinesAny, CharRange}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{Split, RSplit}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{SplitN, RSplitN}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{SplitTerminator, RSplitTerminator}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{Matches, RMatches}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{MatchIndices, RMatchIndices}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{from_utf8, Chars, CharIndices, Bytes}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::{from_utf8_unchecked, ParseBoolError}; +#[stable(feature = "rust1", since = "1.0.0")] pub use rustc_unicode::str::{SplitWhitespace}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::str::pattern; +#[unstable(feature = "slice_concat_ext", + reason = "trait should not have to exist", + issue = "27747")] impl> SliceConcatExt for [S] { type Output = String; diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 804e798c600a5..84667e04e04cb 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -949,6 +949,9 @@ impl Extend for String { } /// A convenience impl that delegates to the impl for `&str` +#[unstable(feature = "pattern", + reason = "API not fully fleshed out and ready to be stabilized", + issue = "27721")] impl<'a, 'b> Pattern<'a> for &'b String { type Searcher = <&'b str as Pattern<'a>>::Searcher; @@ -1143,24 +1146,28 @@ impl FromStr for String { } } +#[stable(feature = "str_parse_error", since = "1.5.0")] impl Clone for ParseError { fn clone(&self) -> ParseError { match *self {} } } +#[stable(feature = "str_parse_error", since = "1.5.0")] impl fmt::Debug for ParseError { fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result { match *self {} } } +#[stable(feature = "str_parse_error", since = "1.5.0")] impl PartialEq for ParseError { fn eq(&self, _: &ParseError) -> bool { match *self {} } } +#[stable(feature = "str_parse_error", since = "1.5.0")] impl Eq for ParseError {} /// A generic trait for converting a value to a string @@ -1287,7 +1294,9 @@ pub struct Drain<'a> { iter: Chars<'a>, } +#[unstable(feature = "drain", reason = "recently added", issue = "27711")] unsafe impl<'a> Sync for Drain<'a> {} +#[unstable(feature = "drain", reason = "recently added", issue = "27711")] unsafe impl<'a> Send for Drain<'a> {} #[unstable(feature = "drain", reason = "recently added", issue = "27711")] diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 9153d624268ed..a6d0de18eb6ed 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -1471,12 +1471,14 @@ impl<'a, T> FromIterator for Cow<'a, [T]> where T: Clone { } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: 'a> IntoCow<'a, [T]> for Vec where T: Clone { fn into_cow(self) -> Cow<'a, [T]> { Cow::Owned(self) } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> IntoCow<'a, [T]> for &'a [T] where T: Clone { fn into_cow(self) -> Cow<'a, [T]> { Cow::Borrowed(self) @@ -1495,7 +1497,9 @@ pub struct IntoIter { end: *const T } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for IntoIter { } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for IntoIter { } #[stable(feature = "rust1", since = "1.0.0")] @@ -1590,7 +1594,9 @@ pub struct Drain<'a, T: 'a> { vec: *mut Vec, } +#[unstable(feature = "drain", reason = "recently added", issue = "27711")] unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {} +#[unstable(feature = "drain", reason = "recently added", issue = "27711")] unsafe impl<'a, T: Send> Send for Drain<'a, T> {} #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs index 67db0227cbee9..1064fcdd9178b 100644 --- a/src/libcollections/vec_deque.rs +++ b/src/libcollections/vec_deque.rs @@ -1662,6 +1662,7 @@ pub struct Iter<'a, T:'a> { } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Iter<'a, T> { Iter { @@ -1805,7 +1806,9 @@ pub struct Drain<'a, T: 'a> { deque: *mut VecDeque, } +#[unstable(feature = "drain", issue = "27711")] unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {} +#[unstable(feature = "drain", issue = "27711")] unsafe impl<'a, T: Send> Send for Drain<'a, T> {} #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 16760f7170708..61c64ab8deebd 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -97,6 +97,7 @@ pub trait Any: Reflect + 'static { fn get_type_id(&self) -> TypeId; } +#[stable(feature = "rust1", since = "1.0.0")] impl Any for T { fn get_type_id(&self) -> TypeId { TypeId::of::() } } diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 59b05c21d8005..789b75836d0a7 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -791,6 +791,7 @@ pub struct UnsafeCell { value: T, } +#[stable(feature = "rust1", since = "1.0.0")] impl !Sync for UnsafeCell {} impl UnsafeCell { diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 21146f98360f7..525f9490b17df 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -152,6 +152,9 @@ pub trait CharExt { fn encode_utf16(self, dst: &mut [u16]) -> Option; } +#[unstable(feature = "core_char_ext", + reason = "the stable interface is `impl char` in later crate", + issue = "27701")] impl CharExt for char { #[inline] fn is_digit(self, radix: u32) -> bool { diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index dfcc5781f0873..38904b4b9efb7 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -24,10 +24,13 @@ use slice; use str; use self::rt::v1::Alignment; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::num::radix; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::num::Radix; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::num::RadixFmt; - +#[stable(feature = "rust1", since = "1.0.0")] pub use self::builders::{DebugStruct, DebugTuple, DebugSet, DebugList, DebugMap}; mod num; @@ -170,6 +173,8 @@ pub struct ArgumentV1<'a> { formatter: fn(&Void, &mut Formatter) -> Result, } +#[unstable(feature = "fmt_internals", reason = "internal to format_args!", + issue = "0")] impl<'a> Clone for ArgumentV1<'a> { fn clone(&self) -> ArgumentV1<'a> { *self @@ -1568,6 +1573,7 @@ impl Debug for () { f.pad("()") } } +#[stable(feature = "rust1", since = "1.0.0")] impl Debug for PhantomData { fn fmt(&self, f: &mut Formatter) -> Result { f.pad("PhantomData") diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 23642790a8898..bfae64f24cfe6 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -264,6 +264,7 @@ const DEC_DIGITS_LUT: &'static[u8] = macro_rules! impl_Display { ($($t:ident),*: $conv_fn:ident) => ($( + #[stable(feature = "rust1", since = "1.0.0")] impl fmt::Display for $t { #[allow(unused_comparisons)] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index ea3a2f78d564a..3cb0691b42160 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -75,6 +75,7 @@ use prelude::v1::*; use mem; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::sip::SipHasher; mod sip; diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 8558927e4acae..bf75c598cc7d5 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -3488,6 +3488,7 @@ impl Peekable { /// /// assert_eq!(iter.is_empty(), true); /// ``` + #[unstable(feature = "core", issue = "27701")] #[inline] pub fn is_empty(&mut self) -> bool { self.peek().is_none() @@ -3991,6 +3992,9 @@ pub trait Step: PartialOrd + Sized { macro_rules! step_impl_unsigned { ($($t:ty)*) => ($( + #[unstable(feature = "step_trait", + reason = "likely to be replaced by finer-grained traits", + issue = "27741")] impl Step for $t { #[inline] fn step(&self, by: &$t) -> Option<$t> { @@ -4018,6 +4022,9 @@ macro_rules! step_impl_unsigned { } macro_rules! step_impl_signed { ($($t:ty)*) => ($( + #[unstable(feature = "step_trait", + reason = "likely to be replaced by finer-grained traits", + issue = "27741")] impl Step for $t { #[inline] fn step(&self, by: &$t) -> Option<$t> { @@ -4057,6 +4064,9 @@ macro_rules! step_impl_signed { macro_rules! step_impl_no_between { ($($t:ty)*) => ($( + #[unstable(feature = "step_trait", + reason = "likely to be replaced by finer-grained traits", + issue = "27741")] impl Step for $t { #[inline] fn step(&self, by: &$t) -> Option<$t> { diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 84a6196cc87ae..e41d63c7e6ee0 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -31,9 +31,12 @@ pub unsafe trait Send { // empty. } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for .. { } +#[stable(feature = "rust1", since = "1.0.0")] impl !Send for *const T { } +#[stable(feature = "rust1", since = "1.0.0")] impl !Send for *mut T { } /// Types with a constant size known at compile-time. @@ -223,48 +226,59 @@ pub unsafe trait Sync { // Empty } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for .. { } +#[stable(feature = "rust1", since = "1.0.0")] impl !Sync for *const T { } +#[stable(feature = "rust1", since = "1.0.0")] impl !Sync for *mut T { } macro_rules! impls{ ($t: ident) => ( + #[stable(feature = "rust1", since = "1.0.0")] impl Hash for $t { #[inline] fn hash(&self, _: &mut H) { } } + #[stable(feature = "rust1", since = "1.0.0")] impl cmp::PartialEq for $t { fn eq(&self, _other: &$t) -> bool { true } } + #[stable(feature = "rust1", since = "1.0.0")] impl cmp::Eq for $t { } + #[stable(feature = "rust1", since = "1.0.0")] impl cmp::PartialOrd for $t { fn partial_cmp(&self, _other: &$t) -> Option { Option::Some(cmp::Ordering::Equal) } } + #[stable(feature = "rust1", since = "1.0.0")] impl cmp::Ord for $t { fn cmp(&self, _other: &$t) -> cmp::Ordering { cmp::Ordering::Equal } } + #[stable(feature = "rust1", since = "1.0.0")] impl Copy for $t { } + #[stable(feature = "rust1", since = "1.0.0")] impl Clone for $t { fn clone(&self) -> $t { $t } } + #[stable(feature = "rust1", since = "1.0.0")] impl Default for $t { fn default() -> $t { $t @@ -387,7 +401,9 @@ impls! { PhantomData } mod impls { use super::{Send, Sync, Sized}; + #[stable(feature = "rust1", since = "1.0.0")] unsafe impl<'a, T: Sync + ?Sized> Send for &'a T {} + #[stable(feature = "rust1", since = "1.0.0")] unsafe impl<'a, T: Send + ?Sized> Send for &'a mut T {} } @@ -433,4 +449,7 @@ mod impls { ensure all type parameters are bounded by `Any`"] pub trait Reflect {} +#[unstable(feature = "reflect_marker", + reason = "requires RFC and more experience", + issue = "27749")] impl Reflect for .. { } diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index 6185823d00132..1261bd0388cc9 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -141,6 +141,9 @@ pub mod consts { pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32; } +#[unstable(feature = "core_float", + reason = "stable interface is via `impl f{32,64}` in later crates", + issue = "27702")] impl Float for f32 { #[inline] fn nan() -> f32 { NAN } diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index f85f8c5bd1433..c4a24631552b0 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -141,6 +141,9 @@ pub mod consts { pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64; } +#[unstable(feature = "core_float", + reason = "stable interface is via `impl f{32,64}` in later crates", + issue = "27702")] impl Float for f64 { #[inline] fn nan() -> f64 { NAN } diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index c0f65fea7db38..fdff49b1a5779 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -77,10 +77,16 @@ pub trait One: Sized { macro_rules! zero_one_impl { ($($t:ty)*) => ($( + #[unstable(feature = "zero_one", + reason = "unsure of placement, wants to use associated constants", + issue = "27739")] impl Zero for $t { #[inline] fn zero() -> Self { 0 } } + #[unstable(feature = "zero_one", + reason = "unsure of placement, wants to use associated constants", + issue = "27739")] impl One for $t { #[inline] fn one() -> Self { 1 } @@ -91,10 +97,16 @@ zero_one_impl! { u8 u16 u32 u64 usize i8 i16 i32 i64 isize } macro_rules! zero_one_impl_float { ($($t:ty)*) => ($( + #[unstable(feature = "zero_one", + reason = "unsure of placement, wants to use associated constants", + issue = "27739")] impl Zero for $t { #[inline] fn zero() -> Self { 0.0 } } + #[unstable(feature = "zero_one", + reason = "unsure of placement, wants to use associated constants", + issue = "27739")] impl One for $t { #[inline] fn one() -> Self { 1.0 } @@ -1938,6 +1950,7 @@ impl fmt::Display for ParseIntError { } } +#[stable(feature = "rust1", since = "1.0.0")] pub use num::dec2flt::ParseFloatError; // Conversion traits for primitive integer and float types diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 7ad49eef8f711..c379b8744acd4 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -894,6 +894,7 @@ pub trait Shr { macro_rules! shr_impl { ($t:ty, $f:ty) => ( + #[stable(feature = "rust1", since = "1.0.0")] impl Shr<$f> for $t { type Output = $t; @@ -1731,6 +1732,7 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T { #[fundamental] // so that regex can rely that `&str: !FnMut` pub trait Fn : FnMut { /// This is called when the call operator is used. + #[unstable(feature = "core", issue = "27701")] extern "rust-call" fn call(&self, args: Args) -> Self::Output; } @@ -1741,6 +1743,7 @@ pub trait Fn : FnMut { #[fundamental] // so that regex can rely that `&str: !FnMut` pub trait FnMut : FnOnce { /// This is called when the call operator is used. + #[unstable(feature = "core", issue = "27701")] extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; } @@ -1751,9 +1754,11 @@ pub trait FnMut : FnOnce { #[fundamental] // so that regex can rely that `&str: !FnMut` pub trait FnOnce { /// The returned type after the call operator is used. + #[unstable(feature = "core", issue = "27701")] type Output; /// This is called when the call operator is used. + #[unstable(feature = "core", issue = "27701")] extern "rust-call" fn call_once(self, args: Args) -> Self::Output; } @@ -1761,6 +1766,7 @@ mod impls { use marker::Sized; use super::{Fn, FnMut, FnOnce}; + #[stable(feature = "rust1", since = "1.0.0")] impl<'a,A,F:?Sized> Fn for &'a F where F : Fn { @@ -1769,6 +1775,7 @@ mod impls { } } + #[stable(feature = "rust1", since = "1.0.0")] impl<'a,A,F:?Sized> FnMut for &'a F where F : Fn { @@ -1777,6 +1784,7 @@ mod impls { } } + #[stable(feature = "rust1", since = "1.0.0")] impl<'a,A,F:?Sized> FnOnce for &'a F where F : Fn { @@ -1787,6 +1795,7 @@ mod impls { } } + #[stable(feature = "rust1", since = "1.0.0")] impl<'a,A,F:?Sized> FnMut for &'a mut F where F : FnMut { @@ -1795,6 +1804,7 @@ mod impls { } } + #[stable(feature = "rust1", since = "1.0.0")] impl<'a,A,F:?Sized> FnOnce for &'a mut F where F : FnMut { @@ -1814,25 +1824,34 @@ pub trait CoerceUnsized { } // &mut T -> &mut U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<&'a mut U> for &'a mut T {} // &mut T -> &U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl<'a, 'b: 'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<&'a U> for &'b mut T {} // &mut T -> *mut U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<*mut U> for &'a mut T {} // &mut T -> *const U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<*const U> for &'a mut T {} // &T -> &U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl<'a, 'b: 'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<&'a U> for &'b T {} // &T -> *const U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl<'a, T: ?Sized+Unsize, U: ?Sized> CoerceUnsized<*const U> for &'a T {} // *mut T -> *mut U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized<*mut U> for *mut T {} // *mut T -> *const U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized<*const U> for *mut T {} // *const T -> *const U +#[unstable(feature = "coerce_unsized", issue = "27732")] impl, U: ?Sized> CoerceUnsized<*const U> for *const T {} /// Both `in (PLACE) EXPR` and `box EXPR` desugar into expressions diff --git a/src/libcore/prelude/v1.rs b/src/libcore/prelude/v1.rs index 0457188586e49..75db6fceab9b7 100644 --- a/src/libcore/prelude/v1.rs +++ b/src/libcore/prelude/v1.rs @@ -17,23 +17,37 @@ #![stable(feature = "core_prelude", since = "1.4.0")] // Reexported core operators +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use marker::{Copy, Send, Sized, Sync}; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce}; // Reexported functions +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use mem::drop; // Reexported types and traits +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use clone::Clone; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord}; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use convert::{AsRef, AsMut, Into, From}; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use default::Default; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use iter::{Iterator, Extend, IntoIterator}; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use iter::{DoubleEndedIterator, ExactSizeIterator}; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use option::Option::{self, Some, None}; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use result::Result::{self, Ok, Err}; // Reexported extension traits for primitive types +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use slice::SliceExt; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use str::StrExt; +#[stable(feature = "core_prelude", since = "1.4.0")] #[doc(no_inline)] pub use char::CharExt; diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 6183034c08426..53ef9cd09026b 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -40,6 +40,7 @@ pub use intrinsics::copy; #[stable(feature = "rust1", since = "1.0.0")] pub use intrinsics::write_bytes; +#[unstable(feature = "drop_in_place", reason = "just exposed, needs FCP", issue = "27908")] pub use intrinsics::drop_in_place; /// Creates a null raw pointer. diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 6e1f120a1db48..d6b6a79d6a869 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -870,6 +870,7 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> { #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> ExactSizeIterator for Iter<'a, T> {} +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Iter<'a, T> { Iter { inner: self.inner } } } diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 8ba4e9605c8e8..efb782fece851 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -154,6 +154,9 @@ macro_rules! slice_ref { }}; } +#[unstable(feature = "core_slice_ext", + reason = "stable interface provided by `impl [T]` in later crates", + issue = "27701")] impl SliceExt for [T] { type Item = T; @@ -796,7 +799,9 @@ pub struct Iter<'a, T: 'a> { _marker: marker::PhantomData<&'a T>, } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl<'a, T: Sync> Sync for Iter<'a, T> {} +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl<'a, T: Sync> Send for Iter<'a, T> {} impl<'a, T> Iter<'a, T> { @@ -842,7 +847,9 @@ pub struct IterMut<'a, T: 'a> { _marker: marker::PhantomData<&'a mut T>, } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl<'a, T: Sync> Sync for IterMut<'a, T> {} +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl<'a, T: Send> Send for IterMut<'a, T> {} impl<'a, T> IterMut<'a, T> { diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 7954bc3a0bf53..f82b9d79d5cd4 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -1440,6 +1440,9 @@ fn slice_error_fail(s: &str, begin: usize, end: usize) -> ! { begin, end, s); } +#[unstable(feature = "core_str_ext", + reason = "stable interface provided by `impl str` in later crates", + issue = "27701")] impl StrExt for str { #[inline] fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool { diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs index 15f46a8602076..21b76c1f4bec1 100644 --- a/src/libcore/sync/atomic.rs +++ b/src/libcore/sync/atomic.rs @@ -86,6 +86,7 @@ pub struct AtomicBool { v: UnsafeCell, } +#[stable(feature = "rust1", since = "1.0.0")] impl Default for AtomicBool { fn default() -> Self { Self::new(Default::default()) @@ -93,6 +94,7 @@ impl Default for AtomicBool { } // Send is implicitly implemented for AtomicBool. +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for AtomicBool {} /// A signed integer type which can be safely shared between threads. @@ -101,6 +103,7 @@ pub struct AtomicIsize { v: UnsafeCell, } +#[stable(feature = "rust1", since = "1.0.0")] impl Default for AtomicIsize { fn default() -> Self { Self::new(Default::default()) @@ -108,6 +111,7 @@ impl Default for AtomicIsize { } // Send is implicitly implemented for AtomicIsize. +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for AtomicIsize {} /// An unsigned integer type which can be safely shared between threads. @@ -116,6 +120,7 @@ pub struct AtomicUsize { v: UnsafeCell, } +#[stable(feature = "rust1", since = "1.0.0")] impl Default for AtomicUsize { fn default() -> Self { Self::new(Default::default()) @@ -123,6 +128,7 @@ impl Default for AtomicUsize { } // Send is implicitly implemented for AtomicUsize. +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for AtomicUsize {} /// A raw pointer type which can be safely shared between threads. @@ -131,13 +137,16 @@ pub struct AtomicPtr { p: UnsafeCell<*mut T>, } +#[stable(feature = "rust1", since = "1.0.0")] impl Default for AtomicPtr { fn default() -> AtomicPtr { AtomicPtr::new(::ptr::null_mut()) } } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for AtomicPtr {} +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for AtomicPtr {} /// Atomic memory orderings diff --git a/src/libcore/tuple.rs b/src/libcore/tuple.rs index 33098cfcf8b6d..4127e182e1d0f 100644 --- a/src/libcore/tuple.rs +++ b/src/libcore/tuple.rs @@ -27,8 +27,6 @@ //! * `Ord` //! * `Default` -#![stable(feature = "rust1", since = "1.0.0")] - use clone::Clone; use cmp::*; use cmp::Ordering::*; diff --git a/src/librustc_unicode/char.rs b/src/librustc_unicode/char.rs index f73cc6837e363..597c517e859e2 100644 --- a/src/librustc_unicode/char.rs +++ b/src/librustc_unicode/char.rs @@ -35,9 +35,11 @@ use core::iter::Iterator; use tables::{derived_property, property, general_category, conversions}; // stable reexports +#[stable(feature = "rust1", since = "1.0.0")] pub use core::char::{MAX, from_u32, from_u32_unchecked, from_digit, EscapeUnicode, EscapeDefault}; // unstable reexports +#[unstable(feature = "unicode", issue = "27783")] pub use tables::UNICODE_VERSION; /// An iterator over the lowercase mapping of a given character, returned from diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index b8482b3a2dc64..c8b377ba3be6c 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -1215,6 +1215,7 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable, hash: SafeHas } } +#[stable(feature = "rust1", since = "1.0.0")] impl PartialEq for HashMap where K: Eq + Hash, V: PartialEq, S: HashState { @@ -1272,6 +1273,7 @@ pub struct Iter<'a, K: 'a, V: 'a> { } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Clone for Iter<'a, K, V> { fn clone(&self) -> Iter<'a, K, V> { Iter { @@ -1299,6 +1301,7 @@ pub struct Keys<'a, K: 'a, V: 'a> { } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Clone for Keys<'a, K, V> { fn clone(&self) -> Keys<'a, K, V> { Keys { @@ -1314,6 +1317,7 @@ pub struct Values<'a, K: 'a, V: 'a> { } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Clone for Values<'a, K, V> { fn clone(&self) -> Values<'a, K, V> { Values { diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index bb7a96bfb4bd6..0021155b00ab7 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -901,6 +901,7 @@ impl IntoIterator for HashSet } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K> Clone for Iter<'a, K> { fn clone(&self) -> Iter<'a, K> { Iter { iter: self.iter.clone() } } } @@ -940,6 +941,7 @@ impl<'a, K> ExactSizeIterator for Drain<'a, K> { fn len(&self) -> usize { self.iter.len() } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for Intersection<'a, T, S> { fn clone(&self) -> Intersection<'a, T, S> { Intersection { iter: self.iter.clone(), ..*self } @@ -969,6 +971,7 @@ impl<'a, T, S> Iterator for Intersection<'a, T, S> } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for Difference<'a, T, S> { fn clone(&self) -> Difference<'a, T, S> { Difference { iter: self.iter.clone(), ..*self } @@ -998,6 +1001,7 @@ impl<'a, T, S> Iterator for Difference<'a, T, S> } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for SymmetricDifference<'a, T, S> { fn clone(&self) -> SymmetricDifference<'a, T, S> { SymmetricDifference { iter: self.iter.clone() } @@ -1014,6 +1018,7 @@ impl<'a, T, S> Iterator for SymmetricDifference<'a, T, S> fn size_hint(&self) -> (usize, Option) { self.iter.size_hint() } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for Union<'a, T, S> { fn clone(&self) -> Union<'a, T, S> { Union { iter: self.iter.clone() } } } diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index 71d9fbfaa3e80..07ddfe237be93 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -408,14 +408,20 @@ #![stable(feature = "rust1", since = "1.0.0")] +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::Bound; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::{BinaryHeap, BTreeMap, BTreeSet}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::{LinkedList, VecDeque}; - +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::{binary_heap, btree_map, btree_set}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::{linked_list, vec_deque}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::hash_map::HashMap; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::hash_set::HashSet; mod hash; @@ -423,12 +429,14 @@ mod hash; #[stable(feature = "rust1", since = "1.0.0")] pub mod hash_map { //! A hashmap + #[stable(feature = "rust1", since = "1.0.0")] pub use super::hash::map::*; } #[stable(feature = "rust1", since = "1.0.0")] pub mod hash_set { //! A hashset + #[stable(feature = "rust1", since = "1.0.0")] pub use super::hash::set::*; } diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs index 191c7dc58060a..e00b02f518c5b 100644 --- a/src/libstd/fs.rs +++ b/src/libstd/fs.rs @@ -324,6 +324,7 @@ impl IntoInner for File { } } +#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for File { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.inner.fmt(f) @@ -1230,6 +1231,7 @@ pub trait PathExt { } #[allow(deprecated)] +#[unstable(feature = "path_ext_deprecated", issue = "27725")] impl PathExt for Path { fn metadata(&self) -> io::Result { metadata(self) } fn symlink_metadata(&self) -> io::Result { symlink_metadata(self) } diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index acab63315e4c4..90a79da348354 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -485,6 +485,7 @@ impl Seek for BufWriter { } } +#[stable(feature = "rust1", since = "1.0.0")] impl Drop for BufWriter { fn drop(&mut self) { if self.inner.is_some() { diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 34736f810339c..ebf322fab4d18 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -255,13 +255,21 @@ use string::String; use str; use vec::Vec; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::buffered::{BufReader, BufWriter, LineWriter}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::buffered::IntoInnerError; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::cursor::Cursor; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::error::{Result, Error, ErrorKind}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::util::{copy, sink, Sink, empty, Empty, repeat, Repeat}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::stdio::{stdin, stdout, stderr, _print, Stdin, Stdout, Stderr}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::stdio::{StdoutLock, StderrLock, StdinLock}; +#[unstable(feature = "libstd_io_internals", issue = "0")] #[doc(no_inline, hidden)] pub use self::stdio::{set_panic, set_print}; diff --git a/src/libstd/io/prelude.rs b/src/libstd/io/prelude.rs index f8fbe485c9b27..f588ec60589e9 100644 --- a/src/libstd/io/prelude.rs +++ b/src/libstd/io/prelude.rs @@ -20,6 +20,8 @@ #![stable(feature = "rust1", since = "1.0.0")] +#[stable(feature = "rust1", since = "1.0.0")] pub use super::{Read, Write, BufRead, Seek}; #[allow(deprecated)] +#[unstable(feature = "path_ext_deprecated", issue = "27725")] pub use fs::PathExt; diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index a0bb9449806e8..6d8d6f82f0736 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -303,36 +303,63 @@ extern crate libc; // NB: These reexports are in the order they should be listed in rustdoc +#[stable(feature = "rust1", since = "1.0.0")] pub use core::any; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::cell; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::clone; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::cmp; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::convert; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::default; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::hash; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::intrinsics; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::iter; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::marker; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::mem; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::ops; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::ptr; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::raw; +#[stable(feature = "rust1", since = "1.0.0")] #[allow(deprecated)] pub use core::simd; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::result; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::option; + pub mod error; +#[stable(feature = "rust1", since = "1.0.0")] pub use alloc::boxed; +#[stable(feature = "rust1", since = "1.0.0")] pub use alloc::rc; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::borrow; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::fmt; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::slice; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::str; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::string; +#[stable(feature = "rust1", since = "1.0.0")] pub use core_collections::vec; +#[stable(feature = "rust1", since = "1.0.0")] pub use rustc_unicode::char; /* Exported macros */ @@ -353,16 +380,26 @@ pub mod prelude; // doc pages are inlined from the public re-exports of core_collections::{slice, // str} above. +#[stable(feature = "rust1", since = "1.0.0")] pub use core::isize; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::i8; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::i16; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::i32; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::i64; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::usize; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::u8; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::u16; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::u32; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::u64; #[path = "num/f32.rs"] pub mod f32; diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index a88ddb997f61d..efeb59b4ac74c 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -259,6 +259,7 @@ pub mod builtin { /// assert_eq!(s, format!("hello {}", "world")); /// /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! format_args { ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ @@ -279,6 +280,7 @@ pub mod builtin { /// let path: &'static str = env!("PATH"); /// println!("the $PATH variable at the time of compiling was: {}", path); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! env { ($name:expr) => ({ /* compiler built-in */ }) } @@ -298,6 +300,7 @@ pub mod builtin { /// let key: Option<&'static str> = option_env!("SECRET_KEY"); /// println!("the secret key might be: {:?}", key); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! option_env { ($name:expr) => ({ /* compiler built-in */ }) } @@ -322,6 +325,7 @@ pub mod builtin { /// println!("{}", f()); /// # } /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! concat_idents { ($($e:ident),*) => ({ /* compiler built-in */ }) @@ -342,6 +346,7 @@ pub mod builtin { /// let s = concat!("test", 10, 'b', true); /// assert_eq!(s, "test10btrue"); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! concat { ($($e:expr),*) => ({ /* compiler built-in */ }) } @@ -357,6 +362,7 @@ pub mod builtin { /// let current_line = line!(); /// println!("defined on line: {}", current_line); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! line { () => ({ /* compiler built-in */ }) } @@ -372,6 +378,7 @@ pub mod builtin { /// let current_col = column!(); /// println!("defined on column: {}", current_col); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! column { () => ({ /* compiler built-in */ }) } @@ -388,6 +395,7 @@ pub mod builtin { /// let this_file = file!(); /// println!("defined in file: {}", this_file); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! file { () => ({ /* compiler built-in */ }) } @@ -403,6 +411,7 @@ pub mod builtin { /// let one_plus_one = stringify!(1 + 1); /// assert_eq!(one_plus_one, "1 + 1"); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! stringify { ($t:tt) => ({ /* compiler built-in */ }) } @@ -417,6 +426,7 @@ pub mod builtin { /// ```rust,ignore /// let secret_key = include_str!("secret-key.ascii"); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! include_str { ($file:expr) => ({ /* compiler built-in */ }) } @@ -431,6 +441,7 @@ pub mod builtin { /// ```rust,ignore /// let secret_key = include_bytes!("secret-key.bin"); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! include_bytes { ($file:expr) => ({ /* compiler built-in */ }) } @@ -451,6 +462,7 @@ pub mod builtin { /// /// test::foo(); /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! module_path { () => ({ /* compiler built-in */ }) } @@ -472,6 +484,7 @@ pub mod builtin { /// "unix-directory" /// }; /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! cfg { ($cfg:tt) => ({ /* compiler built-in */ }) } @@ -486,6 +499,7 @@ pub mod builtin { /// include!("/path/to/a/file") /// } /// ``` + #[stable(feature = "rust1", since = "1.0.0")] #[macro_export] macro_rules! include { ($cfg:tt) => ({ /* compiler built-in */ }) } } diff --git a/src/libstd/net/addr.rs b/src/libstd/net/addr.rs index 66c1ab720b60f..22bb5ff874d3d 100644 --- a/src/libstd/net/addr.rs +++ b/src/libstd/net/addr.rs @@ -448,6 +448,7 @@ impl ToSocketAddrs for str { } } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ToSocketAddrs + ?Sized> ToSocketAddrs for &'a T { type Iter = T::Iter; fn to_socket_addrs(&self) -> io::Result { diff --git a/src/libstd/net/mod.rs b/src/libstd/net/mod.rs index 8a02d37c89be8..383dce737f511 100644 --- a/src/libstd/net/mod.rs +++ b/src/libstd/net/mod.rs @@ -17,10 +17,15 @@ use prelude::v1::*; use io::{self, Error, ErrorKind}; use sys_common::net as net_imp; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::ip::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::addr::{SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::tcp::{TcpStream, TcpListener, Incoming}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::udp::UdpSocket; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::parser::AddrParseError; mod ip; diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs index 93a056faf53f1..fd2e61473f9c0 100644 --- a/src/libstd/net/tcp.rs +++ b/src/libstd/net/tcp.rs @@ -219,6 +219,7 @@ impl IntoInner for TcpStream { fn into_inner(self) -> net_imp::TcpStream { self.0 } } +#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for TcpStream { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt(f) @@ -301,6 +302,7 @@ impl IntoInner for TcpListener { fn into_inner(self) -> net_imp::TcpListener { self.0 } } +#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for TcpListener { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt(f) diff --git a/src/libstd/net/udp.rs b/src/libstd/net/udp.rs index 0d3d15401fd54..b212d4d32aadf 100644 --- a/src/libstd/net/udp.rs +++ b/src/libstd/net/udp.rs @@ -153,6 +153,7 @@ impl IntoInner for UdpSocket { fn into_inner(self) -> net_imp::UdpSocket { self.0 } } +#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for UdpSocket { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.0.fmt(f) diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 439ed40648900..ab25fe17c2c47 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -20,10 +20,15 @@ use intrinsics; use libc::c_int; use num::{FpCategory, ParseFloatError}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f32::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f32::{MIN_EXP, MAX_EXP, MIN_10_EXP}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f32::{MAX_10_EXP, NAN, INFINITY, NEG_INFINITY}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f32::{MIN, MIN_POSITIVE, MAX}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f32::consts; #[allow(dead_code)] diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index aa0e7df76ab77..b392ab0c8daee 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -20,10 +20,15 @@ use intrinsics; use libc::c_int; use num::{FpCategory, ParseFloatError}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f64::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f64::{MIN_EXP, MAX_EXP, MIN_10_EXP}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f64::{MAX_10_EXP, NAN, INFINITY, NEG_INFINITY}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f64::{MIN, MIN_POSITIVE, MAX}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::f64::consts; #[allow(dead_code)] diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index d1ef763e0f620..8e207f5e6cfc5 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -16,8 +16,11 @@ #![stable(feature = "rust1", since = "1.0.0")] #![allow(missing_docs)] +#[stable(feature = "rust1", since = "1.0.0")] pub use core::num::{Zero, One}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::num::{FpCategory, ParseIntError, ParseFloatError}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::num::{wrapping, Wrapping}; #[cfg(test)] use cmp::PartialEq; diff --git a/src/libstd/os/linux/mod.rs b/src/libstd/os/linux/mod.rs index 146a74a4550e4..ea0b00c9998b2 100644 --- a/src/libstd/os/linux/mod.rs +++ b/src/libstd/os/linux/mod.rs @@ -14,7 +14,8 @@ pub mod raw; +#[stable(feature = "raw_ext", since = "1.1.0")] pub mod fs { - #![stable(feature = "raw_ext", since = "1.1.0")] + #[stable(feature = "raw_ext", since = "1.1.0")] pub use sys::fs::MetadataExt; } diff --git a/src/libstd/os/linux/raw.rs b/src/libstd/os/linux/raw.rs index d7abdef6b038f..35de9bfc194d6 100644 --- a/src/libstd/os/linux/raw.rs +++ b/src/libstd/os/linux/raw.rs @@ -16,6 +16,7 @@ #[stable(feature = "raw_ext", since = "1.1.0")] pub type mode_t = u32; #[doc(inline)] +#[stable(feature = "raw_ext", since = "1.1.0")] pub use self::arch::{off_t, ino_t, nlink_t, blksize_t, blkcnt_t, stat, time_t}; #[cfg(any(target_arch = "x86", diff --git a/src/libstd/os/mod.rs b/src/libstd/os/mod.rs index 859cb900460c5..84b7d9fbeec93 100644 --- a/src/libstd/os/mod.rs +++ b/src/libstd/os/mod.rs @@ -13,8 +13,12 @@ #![stable(feature = "os", since = "1.0.0")] #![allow(missing_docs, bad_style)] -#[cfg(unix)] pub use sys::ext as unix; -#[cfg(windows)] pub use sys::ext as windows; +#[cfg(unix)] +#[stable(feature = "rust1", since = "1.0.0")] +pub use sys::ext as unix; +#[cfg(windows)] +#[stable(feature = "rust1", since = "1.0.0")] +pub use sys::ext as windows; #[cfg(target_os = "android")] pub mod android; #[cfg(target_os = "bitrig")] pub mod bitrig; diff --git a/src/libstd/sync/barrier.rs b/src/libstd/sync/barrier.rs index 8360620c3453b..4df6ca5f0b88e 100644 --- a/src/libstd/sync/barrier.rs +++ b/src/libstd/sync/barrier.rs @@ -46,6 +46,7 @@ struct BarrierState { /// /// Currently this opaque structure only has one method, `.is_leader()`. Only /// one thread will receive a result that will return `true` from this function. +#[stable(feature = "rust1", since = "1.0.0")] pub struct BarrierWaitResult(bool); impl Barrier { diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs index 4544f30d4f497..e1b7930b6d82e 100644 --- a/src/libstd/sync/mod.rs +++ b/src/libstd/sync/mod.rs @@ -17,17 +17,28 @@ #![stable(feature = "rust1", since = "1.0.0")] +#[stable(feature = "rust1", since = "1.0.0")] pub use alloc::arc::{Arc, Weak}; +#[stable(feature = "rust1", since = "1.0.0")] pub use core::sync::atomic; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::barrier::{Barrier, BarrierWaitResult}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::condvar::{Condvar, StaticCondvar, WaitTimeoutResult, CONDVAR_INIT}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::mutex::MUTEX_INIT; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::mutex::{Mutex, MutexGuard, StaticMutex}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::once::{Once, ONCE_INIT}; +#[stable(feature = "rust1", since = "1.0.0")] pub use sys_common::poison::{PoisonError, TryLockError, TryLockResult, LockResult}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::rwlock::{RwLockReadGuard, RwLockWriteGuard}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::rwlock::{RwLock, StaticRwLock, RW_LOCK_INIT}; +#[stable(feature = "rust1", since = "1.0.0")] pub use self::semaphore::{Semaphore, SemaphoreGuard}; pub mod mpsc; diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index a0d0147296a96..e87ae19c583f7 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -272,6 +272,7 @@ use mem; use cell::UnsafeCell; use marker::Reflect; +#[unstable(feature = "mpsc_select", issue = "27800")] pub use self::select::{Select, Handle}; use self::select::StartResult; use self::select::StartResult::*; @@ -295,6 +296,7 @@ pub struct Receiver { // The receiver port can be sent from place to place, so long as it // is not used to receive non-sendable things. +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Receiver { } /// An iterator over messages on a receiver, this iterator will block @@ -322,6 +324,7 @@ pub struct Sender { // The send port can be sent from place to place, so long as it // is not used to send non-sendable things. +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Sender { } /// The sending-half of Rust's synchronous channel type. This half can only be @@ -331,8 +334,10 @@ pub struct SyncSender { inner: Arc>>, } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for SyncSender {} +#[stable(feature = "rust1", since = "1.0.0")] impl !Sync for SyncSender {} /// An error returned from the `send` function on channels. @@ -954,6 +959,7 @@ impl<'a, T> IntoIterator for &'a Receiver { fn into_iter(self) -> Iter<'a, T> { self.iter() } } +#[stable(feature = "receiver_into_iter", since = "1.1.0")] impl Iterator for IntoIter { type Item = T; fn next(&mut self) -> Option { self.rx.recv().ok() } diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs index e4eba3d3d2065..6a6c19cfcc308 100644 --- a/src/libstd/sync/mpsc/mpsc_queue.rs +++ b/src/libstd/sync/mpsc/mpsc_queue.rs @@ -133,7 +133,6 @@ impl Queue { } } -#[stable(feature = "rust1", since = "1.0.0")] impl Drop for Queue { fn drop(&mut self) { unsafe { diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index 48631bfc5f9de..5677c5538c45b 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -125,8 +125,9 @@ pub struct Mutex { // these are the only places where `T: Send` matters; all other // functionality works fine on a single thread. +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for Mutex { } - +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for Mutex { } /// The static mutex type is provided to allow for static allocation of mutexes. @@ -175,6 +176,7 @@ pub struct MutexGuard<'a, T: ?Sized + 'a> { __poison: poison::Guard, } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized> !marker::Send for MutexGuard<'a, T> {} /// Static initialization of a mutex. This constant can be used to initialize diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 750c9e30c5c37..4c236d215455d 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -71,7 +71,9 @@ pub struct RwLock { data: UnsafeCell, } +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Send for RwLock {} +#[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for RwLock {} /// Structure representing a statically allocated RwLock. @@ -122,6 +124,7 @@ pub struct RwLockReadGuard<'a, T: ?Sized + 'a> { __data: &'a UnsafeCell, } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized> !marker::Send for RwLockReadGuard<'a, T> {} /// RAII structure used to release the exclusive write access of a lock when @@ -134,6 +137,7 @@ pub struct RwLockWriteGuard<'a, T: ?Sized + 'a> { __poison: poison::Guard, } +#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T: ?Sized> !marker::Send for RwLockWriteGuard<'a, T> {} impl RwLock { diff --git a/src/libstd/sys/common/poison.rs b/src/libstd/sys/common/poison.rs index c6917d8fca5f4..446a4445b2d3a 100644 --- a/src/libstd/sys/common/poison.rs +++ b/src/libstd/sys/common/poison.rs @@ -110,6 +110,7 @@ impl fmt::Display for PoisonError { } } +#[stable(feature = "rust1", since = "1.0.0")] impl Error for PoisonError { fn description(&self) -> &str { "poisoned lock: another task failed inside" @@ -139,6 +140,7 @@ impl PoisonError { pub fn get_mut(&mut self) -> &mut T { &mut self.guard } } +#[stable(feature = "rust1", since = "1.0.0")] impl From> for TryLockError { fn from(err: PoisonError) -> TryLockError { TryLockError::Poisoned(err) @@ -162,6 +164,7 @@ impl fmt::Display for TryLockError { } } +#[stable(feature = "rust1", since = "1.0.0")] impl Error for TryLockError { fn description(&self) -> &str { match *self { diff --git a/src/libstd/sys/common/unwind/mod.rs b/src/libstd/sys/common/unwind/mod.rs index e455d163ed9bf..aea5acc907176 100644 --- a/src/libstd/sys/common/unwind/mod.rs +++ b/src/libstd/sys/common/unwind/mod.rs @@ -203,6 +203,9 @@ pub extern fn rust_begin_unwind(msg: fmt::Arguments, /// site as much as possible (so that `panic!()` has as low an impact /// on (e.g.) the inlining of other functions as possible), by moving /// the actual formatting into this shared place. +#[unstable(feature = "libstd_sys_internals", + reason = "used by the panic! macro", + issue = "0")] #[inline(never)] #[cold] pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, u32)) -> ! { use fmt::Write; @@ -218,6 +221,9 @@ pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, u32)) -> } /// This is the entry point of unwinding for panic!() and assert!(). +#[unstable(feature = "libstd_sys_internals", + reason = "used by the panic! macro", + issue = "0")] #[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible pub fn begin_unwind(msg: M, file_line: &(&'static str, u32)) -> ! { // Note that this should be the only allocation performed in this code path. diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs index 271aba680a2d6..702a34633dc25 100644 --- a/src/libstd/sys/common/wtf8.rs +++ b/src/libstd/sys/common/wtf8.rs @@ -715,6 +715,7 @@ impl<'a> Iterator for Wtf8CodePoints<'a> { } } +#[stable(feature = "rust1", since = "1.0.0")] #[derive(Clone)] pub struct EncodeWide<'a> { code_points: Wtf8CodePoints<'a>, @@ -722,6 +723,7 @@ pub struct EncodeWide<'a> { } // Copied from libunicode/u_str.rs +#[stable(feature = "rust1", since = "1.0.0")] impl<'a> Iterator for EncodeWide<'a> { type Item = u16; diff --git a/src/libstd/sys/unix/ext/fs.rs b/src/libstd/sys/unix/ext/fs.rs index 5ef37ae51c994..d2a16b5de9775 100644 --- a/src/libstd/sys/unix/ext/fs.rs +++ b/src/libstd/sys/unix/ext/fs.rs @@ -153,6 +153,7 @@ pub trait MetadataExt { fn blocks(&self) -> raw::blkcnt_t; } +#[stable(feature = "metadata_ext", since = "1.1.0")] impl MetadataExt for fs::Metadata { fn dev(&self) -> raw::dev_t { self.as_raw_stat().st_dev as raw::dev_t } fn ino(&self) -> raw::ino_t { self.as_raw_stat().st_ino as raw::ino_t } @@ -211,6 +212,7 @@ pub trait DirEntryExt { fn ino(&self) -> raw::ino_t; } +#[stable(feature = "dir_entry_ext", since = "1.1.0")] impl DirEntryExt for fs::DirEntry { fn ino(&self) -> raw::ino_t { self.as_inner().ino() } } @@ -253,6 +255,8 @@ pub trait DirBuilderExt { fn mode(&mut self, mode: raw::mode_t) -> &mut Self; } +#[unstable(feature = "dir_builder", reason = "recently added API", + issue = "27710")] impl DirBuilderExt for fs::DirBuilder { fn mode(&mut self, mode: raw::mode_t) -> &mut fs::DirBuilder { self.as_inner_mut().set_mode(mode); diff --git a/src/libstd/sys/unix/ext/mod.rs b/src/libstd/sys/unix/ext/mod.rs index 5b9f36cbc373a..b57e325089d26 100644 --- a/src/libstd/sys/unix/ext/mod.rs +++ b/src/libstd/sys/unix/ext/mod.rs @@ -40,13 +40,13 @@ pub mod raw; /// Includes all extension traits, and some important type definitions. #[stable(feature = "rust1", since = "1.0.0")] pub mod prelude { - #[doc(no_inline)] + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::io::{RawFd, AsRawFd, FromRawFd, IntoRawFd}; #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::ffi::{OsStrExt, OsStringExt}; - #[doc(no_inline)] + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::fs::{PermissionsExt, OpenOptionsExt, MetadataExt, FileTypeExt}; - #[doc(no_inline)] + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::fs::{DirEntryExt}; #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::process::{CommandExt, ExitStatusExt}; diff --git a/src/libstd/sys/unix/ext/process.rs b/src/libstd/sys/unix/ext/process.rs index 3e7260f07571d..e1111f25db721 100644 --- a/src/libstd/sys/unix/ext/process.rs +++ b/src/libstd/sys/unix/ext/process.rs @@ -107,18 +107,21 @@ impl AsRawFd for process::ChildStderr { } } +#[stable(feature = "process_extensions", since = "1.2.0")] impl IntoRawFd for process::ChildStdin { fn into_raw_fd(self) -> RawFd { self.into_inner().into_fd().into_raw() } } +#[stable(feature = "process_extensions", since = "1.2.0")] impl IntoRawFd for process::ChildStdout { fn into_raw_fd(self) -> RawFd { self.into_inner().into_fd().into_raw() } } +#[stable(feature = "process_extensions", since = "1.2.0")] impl IntoRawFd for process::ChildStderr { fn into_raw_fd(self) -> RawFd { self.into_inner().into_fd().into_raw() diff --git a/src/libstd/sys/unix/ext/raw.rs b/src/libstd/sys/unix/ext/raw.rs index fa380abe6c54d..8377e53f4178b 100644 --- a/src/libstd/sys/unix/ext/raw.rs +++ b/src/libstd/sys/unix/ext/raw.rs @@ -17,6 +17,8 @@ #[stable(feature = "raw_ext", since = "1.1.0")] pub type pid_t = i32; #[doc(inline)] +#[stable(feature = "raw_ext", since = "1.1.0")] pub use sys::platform::raw::{dev_t, ino_t, mode_t, nlink_t, off_t, blksize_t}; #[doc(inline)] +#[stable(feature = "raw_ext", since = "1.1.0")] pub use sys::platform::raw::{blkcnt_t, time_t}; diff --git a/src/libstd/sys/unix/time.rs b/src/libstd/sys/unix/time.rs index 5192f01269d0c..9b093f60f03b0 100644 --- a/src/libstd/sys/unix/time.rs +++ b/src/libstd/sys/unix/time.rs @@ -98,6 +98,7 @@ mod inner { } } + #[unstable(feature = "libstd_sys_internals", issue = "0")] impl<'a> Sub for &'a SteadyTime { type Output = Duration; diff --git a/src/libstd/sys/windows/ext/ffi.rs b/src/libstd/sys/windows/ext/ffi.rs index 3fa96f4dd13e9..253787546c1dc 100644 --- a/src/libstd/sys/windows/ext/ffi.rs +++ b/src/libstd/sys/windows/ext/ffi.rs @@ -17,6 +17,7 @@ use sys::os_str::Buf; use sys_common::wtf8::Wtf8Buf; use sys_common::{FromInner, AsInner}; +#[stable(feature = "rust1", since = "1.0.0")] pub use sys_common::wtf8::EncodeWide; /// Windows-specific extensions to `OsString`. diff --git a/src/libstd/sys/windows/ext/fs.rs b/src/libstd/sys/windows/ext/fs.rs index 9fe6527d89e89..0d78d4de42b29 100644 --- a/src/libstd/sys/windows/ext/fs.rs +++ b/src/libstd/sys/windows/ext/fs.rs @@ -49,6 +49,9 @@ pub trait OpenOptionsExt { fn share_mode(&mut self, val: u32) -> &mut Self; } +#[unstable(feature = "open_options_ext", + reason = "may require more thought/methods", + issue = "27720")] impl OpenOptionsExt for OpenOptions { fn desired_access(&mut self, access: u32) -> &mut OpenOptions { self.as_inner_mut().desired_access(access); self diff --git a/src/libstd/sys/windows/ext/mod.rs b/src/libstd/sys/windows/ext/mod.rs index f69c2d075e3ea..7f095ae7ff6b5 100644 --- a/src/libstd/sys/windows/ext/mod.rs +++ b/src/libstd/sys/windows/ext/mod.rs @@ -27,12 +27,12 @@ pub mod process; /// Includes all extension traits, and some important type definitions. #[stable(feature = "rust1", since = "1.0.0")] pub mod prelude { - #[doc(no_inline)] + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::io::{RawSocket, RawHandle, AsRawSocket, AsRawHandle}; - #[doc(no_inline)] + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::io::{FromRawSocket, FromRawHandle, IntoRawSocket, IntoRawHandle}; #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::ffi::{OsStrExt, OsStringExt}; - #[doc(no_inline)] + #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")] pub use super::fs::{OpenOptionsExt, MetadataExt}; } diff --git a/src/libstd/sys/windows/ext/process.rs b/src/libstd/sys/windows/ext/process.rs index fde21e9a798ee..dffe68915fb45 100644 --- a/src/libstd/sys/windows/ext/process.rs +++ b/src/libstd/sys/windows/ext/process.rs @@ -32,6 +32,7 @@ impl AsRawHandle for process::Child { } } +#[stable(feature = "process_extensions", since = "1.2.0")] impl IntoRawHandle for process::Child { fn into_raw_handle(self) -> RawHandle { self.into_inner().into_handle().into_raw() as *mut _ @@ -59,18 +60,21 @@ impl AsRawHandle for process::ChildStderr { } } +#[stable(feature = "process_extensions", since = "1.2.0")] impl IntoRawHandle for process::ChildStdin { fn into_raw_handle(self) -> RawHandle { self.into_inner().into_handle().into_raw() as *mut _ } } +#[stable(feature = "process_extensions", since = "1.2.0")] impl IntoRawHandle for process::ChildStdout { fn into_raw_handle(self) -> RawHandle { self.into_inner().into_handle().into_raw() as *mut _ } } +#[stable(feature = "process_extensions", since = "1.2.0")] impl IntoRawHandle for process::ChildStderr { fn into_raw_handle(self) -> RawHandle { self.into_inner().into_handle().into_raw() as *mut _ diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs index 4dc7997d22e85..707e8c05e17c8 100644 --- a/src/libstd/sys/windows/time.rs +++ b/src/libstd/sys/windows/time.rs @@ -39,6 +39,7 @@ fn frequency() -> c::LARGE_INTEGER { } } +#[unstable(feature = "libstd_sys_internals", issue = "0")] impl<'a> Sub for &'a SteadyTime { type Output = Duration; diff --git a/src/libstd/thread/mod.rs b/src/libstd/thread/mod.rs index 75e3a52feea65..84ceb9b0a5113 100644 --- a/src/libstd/thread/mod.rs +++ b/src/libstd/thread/mod.rs @@ -189,7 +189,9 @@ pub use self::local::{LocalKey, LocalKeyState}; issue = "27715")] pub use self::scoped_tls::ScopedKey; +#[unstable(feature = "libstd_thread_internals", issue = "0")] #[doc(hidden)] pub use self::local::__KeyInner as __LocalKeyInner; +#[unstable(feature = "libstd_thread_internals", issue = "0")] #[doc(hidden)] pub use self::scoped_tls::__KeyInner as __ScopedKeyInner; //////////////////////////////////////////////////////////////////////////////// diff --git a/src/libstd/thread/scoped_tls.rs b/src/libstd/thread/scoped_tls.rs index 87f58b4c84910..2c92bc504c896 100644 --- a/src/libstd/thread/scoped_tls.rs +++ b/src/libstd/thread/scoped_tls.rs @@ -65,6 +65,9 @@ pub struct ScopedKey { inner: fn() -> &'static imp::KeyInner } /// /// See [ScopedKey documentation](thread/struct.ScopedKey.html) for more /// information. +#[unstable(feature = "thread_local_internals", + reason = "should not be necessary", + issue = "0")] #[macro_export] #[allow_internal_unstable] macro_rules! scoped_thread_local { @@ -80,7 +83,8 @@ macro_rules! scoped_thread_local { #[doc(hidden)] #[unstable(feature = "thread_local_internals", - reason = "should not be necessary")] + reason = "should not be necessary", + issue = "0")] #[macro_export] #[allow_internal_unstable] #[cfg(no_elf_tls)] @@ -95,7 +99,8 @@ macro_rules! __scoped_thread_local_inner { #[doc(hidden)] #[unstable(feature = "thread_local_internals", - reason = "should not be necessary")] + reason = "should not be necessary", + issue = "0")] #[macro_export] #[allow_internal_unstable] #[cfg(not(no_elf_tls))] diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs index d18d7cbecf4c2..ca04ec81a288c 100644 --- a/src/libstd/time/duration.rs +++ b/src/libstd/time/duration.rs @@ -102,6 +102,7 @@ impl Duration { pub fn subsec_nanos(&self) -> u32 { self.nanos } } +#[stable(feature = "duration", since = "1.3.0")] impl Add for Duration { type Output = Duration; @@ -118,6 +119,7 @@ impl Add for Duration { } } +#[stable(feature = "duration", since = "1.3.0")] impl Sub for Duration { type Output = Duration; @@ -136,6 +138,7 @@ impl Sub for Duration { } } +#[stable(feature = "duration", since = "1.3.0")] impl Mul for Duration { type Output = Duration; @@ -152,6 +155,7 @@ impl Mul for Duration { } } +#[stable(feature = "duration", since = "1.3.0")] impl Div for Duration { type Output = Duration; diff --git a/src/libstd/time/mod.rs b/src/libstd/time/mod.rs index 29df882a0422c..446fbae52f6bb 100644 --- a/src/libstd/time/mod.rs +++ b/src/libstd/time/mod.rs @@ -12,6 +12,7 @@ #![stable(feature = "time", since = "1.3.0")] +#[stable(feature = "time", since = "1.3.0")] pub use self::duration::Duration; mod duration; diff --git a/src/test/auxiliary/inherited_stability.rs b/src/test/auxiliary/inherited_stability.rs index 60477288f7cb0..2a3f6aa49628f 100644 --- a/src/test/auxiliary/inherited_stability.rs +++ b/src/test/auxiliary/inherited_stability.rs @@ -20,6 +20,7 @@ pub fn stable() {} #[stable(feature = "rust1", since = "1.0.0")] pub mod stable_mod { + #[unstable(feature = "test_feature", issue = "0")] pub fn unstable() {} #[stable(feature = "rust1", since = "1.0.0")] @@ -37,6 +38,7 @@ pub mod unstable_mod { #[stable(feature = "rust1", since = "1.0.0")] pub trait Stable { + #[unstable(feature = "test_feature", issue = "0")] fn unstable(&self); #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/test/auxiliary/internal_unstable.rs b/src/test/auxiliary/internal_unstable.rs index d9335eb567f69..20eb99fe91cc7 100644 --- a/src/test/auxiliary/internal_unstable.rs +++ b/src/test/auxiliary/internal_unstable.rs @@ -33,12 +33,14 @@ pub struct Bar { pub x: u8 } +#[stable(feature = "stable", since = "1.0.0")] #[allow_internal_unstable] #[macro_export] macro_rules! call_unstable_allow { () => { $crate::unstable() } } +#[stable(feature = "stable", since = "1.0.0")] #[allow_internal_unstable] #[macro_export] macro_rules! construct_unstable_allow { @@ -47,29 +49,34 @@ macro_rules! construct_unstable_allow { } } +#[stable(feature = "stable", since = "1.0.0")] #[allow_internal_unstable] #[macro_export] macro_rules! call_method_allow { ($e: expr) => { $e.method() } } +#[stable(feature = "stable", since = "1.0.0")] #[allow_internal_unstable] #[macro_export] macro_rules! access_field_allow { ($e: expr) => { $e.x } } +#[stable(feature = "stable", since = "1.0.0")] #[allow_internal_unstable] #[macro_export] macro_rules! pass_through_allow { ($e: expr) => { $e } } +#[stable(feature = "stable", since = "1.0.0")] #[macro_export] macro_rules! call_unstable_noallow { () => { $crate::unstable() } } +#[stable(feature = "stable", since = "1.0.0")] #[macro_export] macro_rules! construct_unstable_noallow { ($e: expr) => { @@ -77,16 +84,19 @@ macro_rules! construct_unstable_noallow { } } +#[stable(feature = "stable", since = "1.0.0")] #[macro_export] macro_rules! call_method_noallow { ($e: expr) => { $e.method() } } +#[stable(feature = "stable", since = "1.0.0")] #[macro_export] macro_rules! access_field_noallow { ($e: expr) => { $e.x } } +#[stable(feature = "stable", since = "1.0.0")] #[macro_export] macro_rules! pass_through_noallow { ($e: expr) => { $e } diff --git a/src/test/auxiliary/lint_stability.rs b/src/test/auxiliary/lint_stability.rs index 260361634ae87..92c98cb7d3518 100644 --- a/src/test/auxiliary/lint_stability.rs +++ b/src/test/auxiliary/lint_stability.rs @@ -93,6 +93,7 @@ pub trait Trait { fn trait_stable_text(&self) {} } +#[stable(feature = "test_feature", since = "1.0.0")] impl Trait for MethodTester {} #[unstable(feature = "test_feature", issue = "0")] @@ -154,16 +155,19 @@ pub struct UnstableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub #[stable(feature = "rust1", since = "1.0.0")] pub struct StableTupleStruct(#[stable(feature = "rust1", since = "1.0.0")] pub isize); +#[stable(feature = "test_feature", since = "1.0.0")] #[macro_export] macro_rules! macro_test { () => (deprecated()); } +#[stable(feature = "test_feature", since = "1.0.0")] #[macro_export] macro_rules! macro_test_arg { ($func:expr) => ($func); } +#[stable(feature = "test_feature", since = "1.0.0")] #[macro_export] macro_rules! macro_test_arg_nested { ($func:ident) => (macro_test_arg!($func())); diff --git a/src/test/compile-fail/issue-17337.rs b/src/test/compile-fail/issue-17337.rs index 501f6eb4deaa0..831462601386f 100644 --- a/src/test/compile-fail/issue-17337.rs +++ b/src/test/compile-fail/issue-17337.rs @@ -12,6 +12,8 @@ #![staged_api] #![deny(deprecated)] +#![unstable(feature = "test_feature", issue = "0")] + struct Foo; impl Foo { diff --git a/src/test/compile-fail/lint-stability-fields.rs b/src/test/compile-fail/lint-stability-fields.rs index 11f641196807e..35013a13e9854 100644 --- a/src/test/compile-fail/lint-stability-fields.rs +++ b/src/test/compile-fail/lint-stability-fields.rs @@ -14,6 +14,8 @@ #![feature(staged_api)] #![staged_api] +#![stable(feature = "rust1", since = "1.0.0")] + mod cross_crate { extern crate lint_stability_fields; diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs index 864aafe5a6b6f..b96f460688007 100644 --- a/src/test/compile-fail/lint-stability.rs +++ b/src/test/compile-fail/lint-stability.rs @@ -18,6 +18,8 @@ #![feature(staged_api)] #![staged_api] +#![stable(feature = "rust1", since = "1.0.0")] + #[macro_use] extern crate lint_stability; @@ -127,7 +129,9 @@ mod cross_crate { ::trait_stable_text(&foo); ::trait_stable_text(&foo); - let _ = DeprecatedStruct { i: 0 }; //~ ERROR use of deprecated item + let _ = DeprecatedStruct { //~ ERROR use of deprecated item + i: 0 //~ ERROR use of deprecated item + }; let _ = DeprecatedUnstableStruct { //~^ ERROR use of deprecated item //~^^ ERROR use of unstable library feature @@ -475,7 +479,7 @@ mod this_crate { #[deprecated(since = "1.0.0", reason = "text")] fn test_fn_body() { fn fn_in_body() {} - fn_in_body(); + fn_in_body(); //~ ERROR use of deprecated item: text } impl MethodTester { @@ -483,7 +487,7 @@ mod this_crate { #[deprecated(since = "1.0.0", reason = "text")] fn test_method_body(&self) { fn fn_in_body() {} - fn_in_body(); + fn_in_body(); //~ ERROR use of deprecated item: text } } diff --git a/src/test/compile-fail/missing-stability.rs b/src/test/compile-fail/missing-stability.rs index 1f68b7dbf5e3a..83ba9d95daf73 100644 --- a/src/test/compile-fail/missing-stability.rs +++ b/src/test/compile-fail/missing-stability.rs @@ -14,6 +14,8 @@ #![feature(staged_api)] #![staged_api] +#![stable(feature = "test_feature", since = "1.0.0")] + pub fn unmarked() { //~^ ERROR This node does not have a stability attribute () diff --git a/src/test/compile-fail/stability-attribute-sanity-2.rs b/src/test/compile-fail/stability-attribute-sanity-2.rs index cdeff7afe1a64..82627daf7fffd 100644 --- a/src/test/compile-fail/stability-attribute-sanity-2.rs +++ b/src/test/compile-fail/stability-attribute-sanity-2.rs @@ -13,6 +13,8 @@ #![feature(staged_api)] #![staged_api] +#![stable(feature = "test_feature", since = "1.0.0")] + #[stable(feature = "a", feature = "b", since = "1.0.0")] //~ ERROR multiple 'feature' items fn f1() { } @@ -22,4 +24,9 @@ fn f2() { } #[unstable(feature = "a", issue = "no")] //~ ERROR incorrect 'issue' fn f3() { } +#[macro_export] +macro_rules! mac { //~ ERROR This node does not have a stability attribute + () => () +} + fn main() { } diff --git a/src/test/compile-fail/stability-attribute-sanity.rs b/src/test/compile-fail/stability-attribute-sanity.rs index f71e66ded7e62..e53ba3e17dd31 100644 --- a/src/test/compile-fail/stability-attribute-sanity.rs +++ b/src/test/compile-fail/stability-attribute-sanity.rs @@ -13,6 +13,8 @@ #![feature(staged_api)] #![staged_api] +#![stable(feature = "rust1", since = "1.0.0")] + mod bogus_attribute_types_1 { #[stable(feature = "a", since = "a", reason)] //~ ERROR unknown meta item 'reason' fn f1() { } diff --git a/src/test/rustdoc/issue-18199.rs b/src/test/rustdoc/issue-18199.rs index 46aac8701fd98..27e6e17a79c07 100644 --- a/src/test/rustdoc/issue-18199.rs +++ b/src/test/rustdoc/issue-18199.rs @@ -14,6 +14,7 @@ /// ``` /// #![staged_api] +/// #![unstable(feature="test", issue="18199")] /// fn main() {} /// ``` pub fn foo() {} diff --git a/src/test/rustdoc/issue-27759.rs b/src/test/rustdoc/issue-27759.rs index 2d5f97b1f9331..dbe12b80b3e3a 100644 --- a/src/test/rustdoc/issue-27759.rs +++ b/src/test/rustdoc/issue-27759.rs @@ -12,6 +12,8 @@ #![staged_api] #![doc(issue_tracker_base_url = "http://issue_url/")] +#![unstable(feature="test", issue="27759")] + // @has issue_27759/unstable/index.html // @has - 'test' // @has - '#27759'