diff options
Diffstat (limited to 'src/libcore')
33 files changed, 289 insertions, 289 deletions
diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 098e96ef4cb..259c749c7c1 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -89,7 +89,7 @@ use intrinsics; #[stable(feature = "grandfathered", since = "1.0.0")] pub trait Any: 'static { /// Get the `TypeId` of `self` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "this method will likely be replaced by an associated static")] fn get_type_id(&self) -> TypeId; } @@ -177,7 +177,7 @@ impl TypeId { /// Returns the `TypeId` of the type this generic function has been /// instantiated with #[cfg(not(stage0))] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "may grow a `Reflect` bound soon via marker traits")] pub fn of<T: ?Sized + 'static>() -> TypeId { TypeId { diff --git a/src/libcore/array.rs b/src/libcore/array.rs index c8a26ff8e9b..3d654907348 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -12,7 +12,7 @@ //! up to a certain length. Eventually we should able to generalize //! to all lengths. -#![unstable(feature = "unnamed_feature")] // not yet reviewed +#![unstable(feature = "core")] // not yet reviewed use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; @@ -39,7 +39,7 @@ macro_rules! array_impls { } } - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "waiting for Show to stabilize")] impl<T:fmt::Show> fmt::Show for [T; $N] { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs index 44b1f2e4560..e4e6fcd3afc 100644 --- a/src/libcore/atomic.rs +++ b/src/libcore/atomic.rs @@ -1036,7 +1036,7 @@ pub fn fence(order: Ordering) { } } -#[deprecated(feature = "unnamed_feature", since = "1.0.0", +#[deprecated(feature = "core", since = "1.0.0", reason = "renamed to AtomicIsize")] #[allow(missing_docs)] pub struct AtomicInt { @@ -1045,7 +1045,7 @@ pub struct AtomicInt { unsafe impl Sync for AtomicInt {} -#[deprecated(feature = "unnamed_feature", since = "1.0.0", +#[deprecated(feature = "core", since = "1.0.0", reason = "renamed to AtomicUsize")] #[allow(missing_docs)] pub struct AtomicUint { @@ -1054,12 +1054,12 @@ pub struct AtomicUint { unsafe impl Sync for AtomicUint {} -#[deprecated(feature = "unnamed_feature", since = "1.0.0", +#[deprecated(feature = "core", since = "1.0.0", reason = "use ATOMIC_ISIZE_INIT instead")] #[allow(missing_docs, deprecated)] pub const ATOMIC_INT_INIT: AtomicInt = AtomicInt { v: UnsafeCell { value: 0 } }; -#[deprecated(feature = "unnamed_feature", since = "1.0.0", +#[deprecated(feature = "core", since = "1.0.0", reason = "use ATOMIC_USIZE_INIT instead")] #[allow(missing_docs, deprecated)] pub const ATOMIC_UINT_INIT: AtomicUint = diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs index 998b2e1b608..0acff877927 100644 --- a/src/libcore/borrow.rs +++ b/src/libcore/borrow.rs @@ -42,7 +42,7 @@ //! is desired, `to_mut` will obtain a mutable references to an owned //! value, cloning if necessary. -#![unstable(feature = "unnamed_feature", +#![unstable(feature = "core", reason = "recently added as part of collections reform")] use clone::Clone; diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 854a68211e4..dfb8d9be81b 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -201,7 +201,7 @@ impl<T:Copy> Cell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -271,7 +271,7 @@ impl<T> RefCell<T> { /// immutable borrows can be taken out at the same time. /// /// Returns `None` if the value is currently mutably borrowed. - #[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")] + #[unstable(feature = "core", reason = "may be renamed or removed")] pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> { match BorrowRef::new(&self.borrow) { Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }), @@ -301,7 +301,7 @@ impl<T> RefCell<T> { /// cannot be borrowed while this borrow is active. /// /// Returns `None` if the value is currently borrowed. - #[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")] + #[unstable(feature = "core", reason = "may be renamed or removed")] pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> { match BorrowRefMut::new(&self.borrow) { Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }), @@ -331,7 +331,7 @@ impl<T> RefCell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -423,7 +423,7 @@ impl<'b, T> Deref for Ref<'b, T> { /// /// A `Clone` implementation would interfere with the widespread /// use of `r.borrow().clone()` to clone the contents of a `RefCell`. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be moved to a method, pending language changes")] pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> { Ref { @@ -528,7 +528,7 @@ pub struct UnsafeCell<T> { /// /// This field should not be accessed directly, it is made public for static /// initializers. - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub value: T, } diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 49faefde118..e0b3cb1c1ec 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -92,7 +92,7 @@ pub fn from_u32(i: u32) -> Option<char> { /// Panics if given an `radix` > 36. /// #[inline] -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub fn from_digit(num: uint, radix: uint) -> Option<char> { if radix > 36 { panic!("from_digit: radix is too high (maximum 36)"); @@ -126,7 +126,7 @@ pub trait CharExt { /// # Panics /// /// Panics if given a radix > 36. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn is_digit(self, radix: uint) -> bool; @@ -141,7 +141,7 @@ pub trait CharExt { /// # Panics /// /// Panics if given a radix outside the range [0..36]. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn to_digit(self, radix: uint) -> Option<uint>; @@ -198,13 +198,13 @@ pub trait CharExt { #[stable(feature = "grandfathered", since = "1.0.0")] impl CharExt for char { - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn is_digit(self, radix: uint) -> bool { self.to_digit(radix).is_some() } - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn to_digit(self, radix: uint) -> Option<uint> { if radix > 36 { @@ -260,7 +260,7 @@ impl CharExt for char { } #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> { // Marked #[inline] to allow llvm optimizing it away @@ -289,7 +289,7 @@ impl CharExt for char { } #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> { // Marked #[inline] to allow llvm optimizing it away @@ -320,7 +320,7 @@ pub struct EscapeUnicode { } #[derive(Clone)] -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] enum EscapeUnicodeState { Backslash, Type, @@ -382,7 +382,7 @@ pub struct EscapeDefault { } #[derive(Clone)] -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] enum EscapeDefaultState { Backslash(char), Char(char), diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 243a30c6737..360bcdddc85 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -36,7 +36,7 @@ pub trait Clone : Sized { /// but can be overridden to reuse the resources of `a` to avoid unnecessary /// allocations. #[inline(always)] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "this function is rarely used")] fn clone_from(&mut self, source: &Self) { *self = source.clone() @@ -82,7 +82,7 @@ clone_impl! { char } macro_rules! extern_fn_clone { ($($A:ident),*) => ( - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "this may not be sufficient for fns with region parameters")] impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType { /// Return a copy of a function pointer diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 079293aa502..8a2188f543a 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -290,7 +290,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T { /// /// Returns the first argument if the comparison determines them to be equal. #[inline] -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { match v1.partial_cmp(&v2) { Some(Less) | Some(Equal) => Some(v1), @@ -303,7 +303,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { /// /// Returns the first argument if the comparison determines them to be equal. #[inline] -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> { match v1.partial_cmp(&v2) { Some(Less) => Some(v2), diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs index fdc659a300b..2bd90e7c964 100644 --- a/src/libcore/finally.rs +++ b/src/libcore/finally.rs @@ -30,7 +30,7 @@ //! }) //! ``` -#![deprecated(feature = "unnamed_feature", since = "1.0.0", +#![deprecated(feature = "core", since = "1.0.0", reason = "It is unclear if this module is more robust than implementing \ Drop on a custom type, and this module is being removed with no \ replacement. Use a custom Drop implementation to regain existing \ diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 532071a8600..1503d585887 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -36,7 +36,7 @@ mod num; mod float; pub mod rt; -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "core and I/O reconciliation may alter this definition")] /// The type returned by formatter methods. pub type Result = result::Result<(), Error>; @@ -46,7 +46,7 @@ pub type Result = result::Result<(), Error>; /// This type does not support transmission of an error other than that an error /// occurred. Any extra information must be arranged to be transmitted through /// some other means. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "core and I/O reconciliation may alter this definition")] #[derive(Copy)] pub struct Error; @@ -60,7 +60,7 @@ pub struct Error; /// This trait should generally not be implemented by consumers of the standard /// library. The `write!` macro accepts an instance of `io::Writer`, and the /// `io::Writer` trait is favored over implementing this trait. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "waiting for core and I/O reconciliation")] pub trait Writer { /// Writes a slice of bytes into this writer, returning whether the write @@ -104,7 +104,7 @@ pub trait Writer { /// A struct to represent both where to emit formatting strings to and how they /// should be formatted. A mutable version of this is passed to all formatting /// traits. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "name may change and implemented traits are also unstable")] pub struct Formatter<'a> { flags: uint, @@ -127,7 +127,7 @@ enum Void {} /// family of functions. It contains a function to format the given value. At /// compile time it is ensured that the function and the value have the correct /// types, and then this struct is used to canonicalize arguments to one type. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "implementation detail of the `format_args!` macro")] #[derive(Copy)] pub struct Argument<'a> { @@ -167,7 +167,7 @@ impl<'a> Arguments<'a> { /// When using the format_args!() macro, this function is used to generate the /// Arguments structure. #[doc(hidden)] #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "implementation detail of the `format_args!` macro")] pub fn new(pieces: &'a [&'a str], args: &'a [Argument<'a>]) -> Arguments<'a> { @@ -185,7 +185,7 @@ impl<'a> Arguments<'a> { /// created with `argumentuint`. However, failing to do so doesn't cause /// unsafety, but will ignore invalid . #[doc(hidden)] #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "implementation detail of the `format_args!` macro")] pub fn with_placeholders(pieces: &'a [&'a str], fmt: &'a [rt::Argument], @@ -236,7 +236,7 @@ impl<'a> String for Arguments<'a> { /// Format trait for the `:?` format. Useful for debugging, most all types /// should implement this. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait Show { /// Formats the value using the given formatter. @@ -245,7 +245,7 @@ pub trait Show { /// When a value can be semantically expressed as a String, this trait may be /// used. It corresponds to the default format, `{}`. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait String { /// Formats the value using the given formatter. @@ -254,7 +254,7 @@ pub trait String { /// Format trait for the `o` character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait Octal { /// Formats the value using the given formatter. @@ -262,7 +262,7 @@ pub trait Octal { } /// Format trait for the `b` character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait Binary { /// Formats the value using the given formatter. @@ -270,7 +270,7 @@ pub trait Binary { } /// Format trait for the `x` character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait LowerHex { /// Formats the value using the given formatter. @@ -278,7 +278,7 @@ pub trait LowerHex { } /// Format trait for the `X` character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait UpperHex { /// Formats the value using the given formatter. @@ -286,7 +286,7 @@ pub trait UpperHex { } /// Format trait for the `p` character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait Pointer { /// Formats the value using the given formatter. @@ -294,7 +294,7 @@ pub trait Pointer { } /// Format trait for the `e` character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait LowerExp { /// Formats the value using the given formatter. @@ -302,7 +302,7 @@ pub trait LowerExp { } /// Format trait for the `E` character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "I/O and core have yet to be reconciled")] pub trait UpperExp { /// Formats the value using the given formatter. @@ -317,7 +317,7 @@ pub trait UpperExp { /// /// * output - the buffer to write output to /// * args - the precompiled arguments generated by `format_args!` -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "libcore and I/O have yet to be reconciled, and this is an \ implementation detail which should not otherwise be exported")] pub fn write(output: &mut Writer, args: Arguments) -> Result { @@ -415,7 +415,7 @@ impl<'a> Formatter<'a> { /// /// This function will correctly account for the flags provided as well as /// the minimum width. It will not take precision into account. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "definition may change slightly over time")] pub fn pad_integral(&mut self, is_positive: bool, @@ -492,7 +492,7 @@ impl<'a> Formatter<'a> { /// is longer than this length /// /// Notably this function ignored the `flag` parameters - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "definition may change slightly over time")] pub fn pad(&mut self, s: &str) -> Result { // Make sure there's a fast path up front @@ -570,38 +570,38 @@ impl<'a> Formatter<'a> { /// Writes some data to the underlying buffer contained within this /// formatter. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "reconciling core and I/O may alter this definition")] pub fn write_str(&mut self, data: &str) -> Result { self.buf.write_str(data) } /// Writes some formatted information into this instance - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "reconciling core and I/O may alter this definition")] pub fn write_fmt(&mut self, fmt: Arguments) -> Result { write(self.buf, fmt) } /// Flags for formatting (packed version of rt::Flag) - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "return type may change and method was just created")] pub fn flags(&self) -> uint { self.flags } /// Character used as 'fill' whenever there is alignment - #[unstable(feature = "unnamed_feature", reason = "method was just created")] + #[unstable(feature = "core", reason = "method was just created")] pub fn fill(&self) -> char { self.fill } /// Flag indicating what form of alignment was requested - #[unstable(feature = "unnamed_feature", reason = "method was just created")] + #[unstable(feature = "core", reason = "method was just created")] pub fn align(&self) -> rt::Alignment { self.align } /// Optionally specified integer width that the output should be - #[unstable(feature = "unnamed_feature", reason = "method was just created")] + #[unstable(feature = "core", reason = "method was just created")] pub fn width(&self) -> Option<uint> { self.width } /// Optionally specified precision for numeric types - #[unstable(feature = "unnamed_feature", reason = "method was just created")] + #[unstable(feature = "core", reason = "method was just created")] pub fn precision(&self) -> Option<uint> { self.precision } } @@ -614,7 +614,7 @@ impl Show for Error { /// This is a function which calls are emitted to by the compiler itself to /// create the Argument structures that are passed into the `format` function. #[doc(hidden)] #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "implementation detail of the `format_args!` macro")] pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, t: &'a T) -> Argument<'a> { @@ -624,7 +624,7 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, /// When the compiler determines that the type of an argument *must* be a uint /// (such as for width and precision), then it invokes this method. #[doc(hidden)] #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "implementation detail of the `format_args!` macro")] pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { Argument::from_uint(s) @@ -879,7 +879,7 @@ impl<T: Copy + Show> Show for Cell<T> { } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<T: Show> Show for RefCell<T> { fn fmt(&self, f: &mut Formatter) -> Result { match self.try_borrow() { diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 710446e42be..83397e5dc99 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -111,7 +111,7 @@ radix! { UpperHex, 16, "0x", x @ 0 ... 9 => b'0' + x, /// A radix with in the range of `2..36`. #[derive(Clone, Copy, PartialEq)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "may be renamed or move to a different module")] pub struct Radix { base: u8, @@ -136,7 +136,7 @@ impl GenericRadix for Radix { } /// A helper type for formatting radixes. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "may be renamed or move to a different module")] #[derive(Copy)] pub struct RadixFmt<T, R>(T, R); @@ -149,7 +149,7 @@ pub struct RadixFmt<T, R>(T, R); /// use std::fmt::radix; /// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string()); /// ``` -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "may be renamed or move to a different module")] pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> { RadixFmt(x, Radix::new(base)) diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs index 483d701c2c3..0b2c1efbc5d 100644 --- a/src/libcore/fmt/rt.rs +++ b/src/libcore/fmt/rt.rs @@ -14,7 +14,7 @@ //! These definitions are similar to their `ct` equivalents, but differ in that //! these can be statically allocated and are slightly optimized for the runtime -#![unstable(feature = "unnamed_feature", +#![unstable(feature = "core", reason = "implementation detail of the `format_args!` macro")] pub use self::Alignment::*; diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index f070b4e0610..5a4d2fffade 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -56,7 +56,7 @@ //! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2)); //! ``` -#![unstable(feature = "unnamed_feature", +#![unstable(feature = "hash", reason = "module was recently redesigned")] use prelude::*; @@ -96,7 +96,7 @@ pub trait Hasher { /// A common bound on the `Hasher` parameter to `Hash` implementations in order /// to generically hash an aggregate. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "hash", reason = "this trait will likely be replaced by io::Writer")] #[allow(missing_docs)] pub trait Writer { diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 3957cba5a00..872b2d031f6 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -39,7 +39,7 @@ //! guaranteed to happen in order. This is the standard mode for working //! with atomic types and is equivalent to Java's `volatile`. -#![unstable(feature = "unnamed_feature")] +#![unstable(feature = "core")] #![allow(missing_docs)] use marker::Sized; @@ -303,7 +303,7 @@ extern "rust-intrinsic" { /// } /// } /// ``` - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint); /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source @@ -333,12 +333,12 @@ extern "rust-intrinsic" { /// } /// ``` /// - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint); /// Invokes memset on the specified pointer, setting `count * size_of::<T>()` /// bytes of memory starting at `dst` to `c`. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "uncertain about naming and semantics")] pub fn set_memory<T>(dst: *mut T, val: u8, count: uint); diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index d0e0b737419..fef11ecba18 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -564,7 +564,7 @@ pub trait IteratorExt: Iterator + Sized { /// assert_eq!(even, vec![2, 4]); /// assert_eq!(odd, vec![1, 3]); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added as part of collections reform")] fn partition<B, F>(mut self, mut f: F) -> (B, B) where B: Default + Extend<Self::Item>, @@ -760,7 +760,7 @@ pub trait IteratorExt: Iterator + Sized { /// let v = [1i, 1, 1, 1]; /// assert!(v.iter().min_max() == MinMax(&1, &1)); /// ``` - #[unstable(feature = "unnamed_feature", reason = "return type may change")] + #[unstable(feature = "core", reason = "return type may change")] fn min_max(mut self) -> MinMaxResult<Self::Item> where Self::Item: Ord { let (mut min, mut max) = match self.next() { @@ -817,7 +817,7 @@ pub trait IteratorExt: Iterator + Sized { /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "may want to produce an Ordering directly; see #15311")] fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, @@ -847,7 +847,7 @@ pub trait IteratorExt: Iterator + Sized { /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "may want to produce an Ordering directly; see #15311")] fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, @@ -887,7 +887,7 @@ pub trait IteratorExt: Iterator + Sized { /// /// Loops through the entire iterator, collecting the first component of /// each item into one new container, and the second component into another. - #[unstable(feature = "unnamed_feature", reason = "recent addition")] + #[unstable(feature = "core", reason = "recent addition")] fn unzip<A, B, FromA, FromB>(mut self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, @@ -920,7 +920,7 @@ pub trait IteratorExt: Iterator + Sized { /// Creates an iterator that clones the elements it yields. Useful for converting an /// Iterator<&T> to an Iterator<T>. - #[unstable(feature = "unnamed_feature", reason = "recent addition")] + #[unstable(feature = "core", reason = "recent addition")] fn cloned<T, D>(self) -> Cloned<Self> where Self: Iterator<Item=D>, D: Deref<Target=T>, @@ -948,7 +948,7 @@ pub trait IteratorExt: Iterator + Sized { } /// Use an iterator to reverse a container in place. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "uncertain about placement or widespread use")] fn reverse_in_place<'a, T: 'a>(&mut self) where Self: Iterator<Item=&'a mut T> + DoubleEndedIterator @@ -982,7 +982,7 @@ pub trait DoubleEndedIterator: Iterator { /// Calling `next()` or `next_back()` on a `RandomAccessIterator` /// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)` /// after `it.next()` is called. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "not widely used, may be better decomposed into Index and ExactSizeIterator")] pub trait RandomAccessIterator: Iterator { /// Return the number of indexable elements. At most `std::uint::MAX` @@ -1058,7 +1058,7 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator { fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator { #[inline] fn indexable(&self) -> uint { self.iter.indexable() } @@ -1093,7 +1093,7 @@ impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterat } /// A trait for iterators over elements which can be added together -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "needs to be re-evaluated as part of numerics reform")] pub trait AdditiveIterator<A> { /// Iterates over the entire iterator, summing up all the elements @@ -1112,7 +1112,7 @@ pub trait AdditiveIterator<A> { macro_rules! impl_additive { ($A:ty, $init:expr) => { - #[unstable(feature = "unnamed_feature", reason = "trait is experimental")] + #[unstable(feature = "core", reason = "trait is experimental")] impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T { #[inline] fn sum(self) -> $A { @@ -1135,7 +1135,7 @@ impl_additive! { f32, 0.0 } impl_additive! { f64, 0.0 } /// A trait for iterators over elements which can be multiplied together. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "needs to be re-evaluated as part of numerics reform")] pub trait MultiplicativeIterator<A> { /// Iterates over the entire iterator, multiplying all the elements @@ -1157,7 +1157,7 @@ pub trait MultiplicativeIterator<A> { macro_rules! impl_multiplicative { ($A:ty, $init:expr) => { - #[unstable(feature = "unnamed_feature", reason = "trait is experimental")] + #[unstable(feature = "core", reason = "trait is experimental")] impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T { #[inline] fn product(self) -> $A { @@ -1181,7 +1181,7 @@ impl_multiplicative! { f64, 1.0 } /// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail. #[derive(Clone, PartialEq, Show)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "unclear whether such a fine-grained result is widely useful")] pub enum MinMaxResult<T> { /// Empty iterator @@ -1214,7 +1214,7 @@ impl<T: Clone> MinMaxResult<T> { /// let r = MinMax(1i,2i); /// assert_eq!(r.into_option(), Some((1,2))); /// ``` - #[unstable(feature = "unnamed_feature", reason = "type is unstable")] + #[unstable(feature = "core", reason = "type is unstable")] pub fn into_option(self) -> Option<(T,T)> { match self { NoElements => None, @@ -1225,7 +1225,7 @@ impl<T: Clone> MinMaxResult<T> { } /// An iterator that clones the elements of an underlying iterator -#[unstable(feature = "unnamed_feature", reason = "recent addition")] +#[unstable(feature = "core", reason = "recent addition")] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[derive(Clone)] pub struct Cloned<I> { @@ -1299,7 +1299,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator { } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<I> RandomAccessIterator for Cycle<I> where I: Clone + RandomAccessIterator, { @@ -1384,7 +1384,7 @@ impl<T, A, B> DoubleEndedIterator for Chain<A, B> where } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<T, A, B> RandomAccessIterator for Chain<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=T>, @@ -1476,7 +1476,7 @@ impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=U>, @@ -1558,7 +1558,7 @@ impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(A) -> B, @@ -1747,7 +1747,7 @@ impl<I> DoubleEndedIterator for Enumerate<I> where } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -1973,7 +1973,7 @@ impl<I> Iterator for Skip<I> where I: Iterator { } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2028,7 +2028,7 @@ impl<I> Iterator for Take<I> where I: Iterator{ } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2241,7 +2241,7 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator { } // Allow RandomAccessIterators to be fused without affecting random-access behavior -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -2258,7 +2258,7 @@ impl<I> Fuse<I> { /// Resets the fuse such that the next call to .next() or .next_back() will /// call the underlying iterator again even if it previously returned None. #[inline] - #[unstable(feature = "unnamed_feature", reason = "seems marginal")] + #[unstable(feature = "core", reason = "seems marginal")] pub fn reset_fuse(&mut self) { self.done = false } @@ -2327,7 +2327,7 @@ impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(&A), @@ -2376,7 +2376,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where /// println!("{}", i); /// } /// ``` -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { f: F, /// Internal state that will be passed to the closure on the next iteration @@ -2397,7 +2397,7 @@ impl<A, St, F> Clone for Unfold<A, St, F> where } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { /// Creates a new iterator with the specified closure as the "iterator /// function" and an initial state to eventually pass to the closure @@ -2429,7 +2429,7 @@ impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A /// An infinite iterator starting at `start` and advancing by `step` with each /// iteration #[derive(Clone, Copy)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "may be renamed or replaced by range notation adapaters")] pub struct Counter<A> { /// The current state the counter is at (next value to be yielded) @@ -2440,7 +2440,7 @@ pub struct Counter<A> { /// Creates a new counter with the specified start/step #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "may be renamed or replaced by range notation adapaters")] pub fn count<A>(start: A, step: A) -> Counter<A> { Counter{state: start, step: step} @@ -2465,7 +2465,7 @@ impl<A: Add<Output=A> + Clone> Iterator for Counter<A> { /// An iterator over the range [start, stop) #[derive(Clone, Copy)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will be replaced by range notation")] pub struct Range<A> { state: A, @@ -2487,7 +2487,7 @@ pub struct Range<A> { /// } /// ``` #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will be replaced by range notation")] pub fn range<A: Int>(start: A, stop: A) -> Range<A> { Range { @@ -2498,7 +2498,7 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> { } // FIXME: #10414: Unfortunate type bound -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will be replaced by range notation")] impl<A: Int + ToPrimitive> Iterator for Range<A> { type Item = A; @@ -2549,7 +2549,7 @@ impl<A: Int + ToPrimitive> Iterator for Range<A> { /// `Int` is required to ensure the range will be the same regardless of /// the direction it is consumed. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will be replaced by range notation")] impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> { #[inline] @@ -2565,7 +2565,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> { /// An iterator over the range [start, stop] #[derive(Clone)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] pub struct RangeInclusive<A> { range: Range<A>, @@ -2574,7 +2574,7 @@ pub struct RangeInclusive<A> { /// Return an iterator over the range [start, stop] #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> { RangeInclusive { @@ -2583,7 +2583,7 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> { } } -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> { type Item = A; @@ -2619,7 +2619,7 @@ impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> { } } -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> { #[inline] @@ -2639,7 +2639,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> { /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[derive(Clone)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] pub struct RangeStep<A> { state: A, @@ -2650,14 +2650,14 @@ pub struct RangeStep<A> { /// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> { let rev = step < Int::zero(); RangeStep{state: start, stop: stop, step: step, rev: rev} } -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] impl<A: Int> Iterator for RangeStep<A> { type Item = A; @@ -2679,7 +2679,7 @@ impl<A: Int> Iterator for RangeStep<A> { /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[derive(Clone)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] pub struct RangeStepInclusive<A> { state: A, @@ -2691,7 +2691,7 @@ pub struct RangeStepInclusive<A> { /// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> { let rev = step < Int::zero(); @@ -2704,7 +2704,7 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl } } -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to be replaced by range notation and adapters")] impl<A: Int> Iterator for RangeStepInclusive<A> { type Item = A; @@ -2730,7 +2730,7 @@ impl<A: Int> Iterator for RangeStepInclusive<A> { /// directions. The `steps_between` function provides a way to /// compare two Step objects (it could be provided using `step()` and `Ord`, /// but the implementation would be so inefficient as to be useless). -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "design of range notation/iteration is in flux")] pub trait Step: Ord { /// Change self to the next object. @@ -2746,7 +2746,7 @@ pub trait Step: Ord { macro_rules! step_impl { ($($t:ty)*) => ($( - #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")] + #[unstable(feature = "core", reason = "Trait is unstable.")] impl Step for $t { #[inline] fn step(&mut self) { *self += 1; } @@ -2763,7 +2763,7 @@ macro_rules! step_impl { macro_rules! step_impl_no_between { ($($t:ty)*) => ($( - #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")] + #[unstable(feature = "core", reason = "Trait is unstable.")] impl Step for $t { #[inline] fn step(&mut self) { *self += 1; } @@ -2807,7 +2807,7 @@ impl<A: Clone> DoubleEndedIterator for Repeat<A> { fn next_back(&mut self) -> Option<A> { self.idx(0) } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<A: Clone> RandomAccessIterator for Repeat<A> { #[inline] fn indexable(&self) -> uint { uint::MAX } @@ -2819,12 +2819,12 @@ type IterateState<T, F> = (F, Option<T>, bool); /// An iterator that repeatedly applies a given function, starting /// from a given seed value. -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>; /// Create a new iterator that produces an infinite sequence of /// repeated applications of the given function `f`. -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where T: Clone, F: FnMut(T) -> T, @@ -2867,7 +2867,7 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> { /// /// If two sequences are equal up until the point where one ends, /// the shorter sequence compares less. -#[unstable(feature = "unnamed_feature", reason = "needs review and revision")] +#[unstable(feature = "core", reason = "needs review and revision")] pub mod order { use cmp; use cmp::{Eq, Ord, PartialOrd, PartialEq}; diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 17460c0d52b..ea697ed769d 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -48,7 +48,7 @@ // separate crate, libcoretest, to avoid bizarre issues. #![crate_name = "core"] -#![unstable(feature = "unnamed_feature")] +#![unstable(feature = "core")] #![feature(staged_api)] #![staged_api] #![crate_type = "rlib"] diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs index 393f8825f5e..87f21e91c62 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -235,7 +235,7 @@ macro_rules! writeln { /// } /// ``` #[macro_export] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "relationship with panic is unclear")] macro_rules! unreachable { () => ({ @@ -252,7 +252,7 @@ macro_rules! unreachable { /// A standardised placeholder for marking unfinished code. It panics with the /// message `"not yet implemented"` when executed. #[macro_export] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "relationship with panic is unclear")] macro_rules! unimplemented { () => (panic!("not yet implemented")) diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 9d8509cd11f..96f65a2b732 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -28,7 +28,7 @@ use clone::Clone; /// Types able to be transferred across task boundaries. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will be overhauled with new lifetime rules; see RFC 458")] #[lang="send"] pub unsafe trait Send: 'static { @@ -192,7 +192,7 @@ pub trait Copy { /// around the value(s) which can be mutated when behind a `&` /// reference; not doing this is undefined behaviour (for example, /// `transmute`-ing from `&T` to `&mut T` is illegal). -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will be overhauled with new lifetime rules; see RFC 458")] #[lang="sync"] pub unsafe trait Sync { @@ -237,7 +237,7 @@ pub unsafe trait Sync { /// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U` /// (for example, `S<&'static int>` is a subtype of `S<&'a int>` /// for some lifetime `'a`, but not the other way around). -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="covariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] @@ -287,7 +287,7 @@ impl<T: ?Sized> Clone for CovariantType<T> { /// subtype of `S<U>` if `U` is a subtype of `T`; given that the /// function requires arguments of type `T`, it must also accept /// arguments of type `U`, hence such a conversion is safe. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="contravariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] @@ -318,16 +318,16 @@ impl<T: ?Sized> Clone for ContravariantType<T> { /// The type system would infer that `value` is only read here and /// never written, but in fact `Cell` uses unsafe code to achieve /// interior mutability. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="invariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] pub struct InvariantType<T: ?Sized>; -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] impl<T: ?Sized> Copy for InvariantType<T> {} -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] impl<T: ?Sized> Clone for InvariantType<T> { fn clone(&self) -> InvariantType<T> { *self } @@ -349,7 +349,7 @@ impl<T: ?Sized> Clone for InvariantType<T> { /// /// For more information about variance, refer to this Wikipedia /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="covariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -367,7 +367,7 @@ pub struct CovariantLifetime<'a>; /// /// For more information about variance, refer to this Wikipedia /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="contravariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -380,7 +380,7 @@ pub struct ContravariantLifetime<'a>; /// pointer that is actually a pointer into memory with lifetime `'a`, /// and this pointer is itself stored in an inherently mutable /// location (such as a `Cell`). -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="invariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -390,7 +390,7 @@ pub struct InvariantLifetime<'a>; /// be safely sent between tasks, even if it is owned. This is /// typically embedded in other types, such as `Gc`, to ensure that /// their instances remain thread-local. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="no_send_bound"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -400,7 +400,7 @@ pub struct NoSend; /// A type which is considered "not POD", meaning that it is not /// implicitly copyable. This is typically embedded in other types to /// ensure that they are never copied, even if they lack a destructor. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="no_copy_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -410,7 +410,7 @@ pub struct NoCopy; /// A type which is considered "not sync", meaning that /// its contents are not threadsafe, hence they cannot be /// shared between tasks. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="no_sync_bound"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -419,7 +419,7 @@ pub struct NoSync; /// A type which is considered managed by the GC. This is typically /// embedded in other types. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "likely to change with new variance strategy")] #[lang="managed_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index bfaf897b3a4..001b58c2460 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -318,7 +318,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U { /// Transforms lifetime of the second pointer to match the first. #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "this function may be removed in the future due to its \ questionable utility")] pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, @@ -328,7 +328,7 @@ pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, /// Transforms lifetime of the second mutable pointer to match the first. #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "this function may be removed in the future due to its \ questionable utility")] pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S, diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs index 601e1b192a9..7c8be79d075 100644 --- a/src/libcore/nonzero.rs +++ b/src/libcore/nonzero.rs @@ -32,7 +32,7 @@ unsafe impl Zeroable for u64 {} /// NULL or 0 that might allow certain optimizations. #[lang="non_zero"] #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)] -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub struct NonZero<T: Zeroable>(T); impl<T: Zeroable> NonZero<T> { diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index 4d5a0c1af4d..8e28bb18aef 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -22,12 +22,12 @@ use num::Float; use num::FpCategory as Fp; use option::Option; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const RADIX: uint = 2u; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MANTISSA_DIGITS: uint = 24u; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const DIGITS: uint = 6u; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -43,14 +43,14 @@ pub const MIN_POS_VALUE: f32 = 1.17549435e-38_f32; #[stable(feature = "grandfathered", since = "1.0.0")] pub const MAX_VALUE: f32 = 3.40282347e+38_f32; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MIN_EXP: int = -125; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MAX_EXP: int = 128; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MIN_10_EXP: int = -37; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MAX_10_EXP: int = 38; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -61,7 +61,7 @@ pub const INFINITY: f32 = 1.0_f32/0.0_f32; pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32; /// Various useful constants. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "naming scheme needs to be revisited")] pub mod consts { // FIXME: replace with mathematical constants from cmath. @@ -118,7 +118,7 @@ pub mod consts { pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32; } -#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] +#[unstable(feature = "core", reason = "trait is unstable")] impl Float for f32 { #[inline] fn nan() -> f32 { NAN } diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index 84a457d78ca..4fee89e923c 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -26,11 +26,11 @@ use option::Option; // constants are implemented in favour of referencing the respective // members of `Bounded` and `Float`. -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const RADIX: uint = 2u; pub const MANTISSA_DIGITS: uint = 53u; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const DIGITS: uint = 15u; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -46,14 +46,14 @@ pub const MIN_POS_VALUE: f64 = 2.2250738585072014e-308_f64; #[stable(feature = "grandfathered", since = "1.0.0")] pub const MAX_VALUE: f64 = 1.7976931348623157e+308_f64; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MIN_EXP: int = -1021; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MAX_EXP: int = 1024; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MIN_10_EXP: int = -307; -#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] +#[unstable(feature = "core", reason = "pending integer conventions")] pub const MAX_10_EXP: int = 308; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -64,7 +64,7 @@ pub const INFINITY: f64 = 1.0_f64/0.0_f64; pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64; /// Various useful constants. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "naming scheme needs to be revisited")] pub mod consts { // FIXME: replace with mathematical constants from cmath. @@ -125,7 +125,7 @@ pub mod consts { pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64; } -#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] +#[unstable(feature = "core", reason = "trait is unstable")] impl Float for f64 { #[inline] fn nan() -> f64 { NAN } diff --git a/src/libcore/num/int_macros.rs b/src/libcore/num/int_macros.rs index af84f619a9d..899f08fb622 100644 --- a/src/libcore/num/int_macros.rs +++ b/src/libcore/num/int_macros.rs @@ -14,11 +14,11 @@ macro_rules! int_module { ($T:ty, $bits:expr) => ( // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // calling the `mem::size_of` function. -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub const BITS : uint = $bits; // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // calling the `mem::size_of` function. -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub const BYTES : uint = ($bits / 8); // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 2321baf3780..5e4956dfccf 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -50,25 +50,25 @@ pub trait Int { /// Returns the `0` value of this integer type. // FIXME (#5527): Should be an associated constant - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "unsure about its place in the world")] fn zero() -> Self; /// Returns the `1` value of this integer type. // FIXME (#5527): Should be an associated constant - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "unsure about its place in the world")] fn one() -> Self; /// Returns the smallest value that can be represented by this integer type. // FIXME (#5527): Should be and associated constant - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "unsure about its place in the world")] fn min_value() -> Self; /// Returns the largest value that can be represented by this integer type. // FIXME (#5527): Should be and associated constant - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "unsure about its place in the world")] fn max_value() -> Self; @@ -83,7 +83,7 @@ pub trait Int /// /// assert_eq!(n.count_ones(), 3); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn count_ones(self) -> uint; @@ -98,7 +98,7 @@ pub trait Int /// /// assert_eq!(n.count_zeros(), 5); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] #[inline] fn count_zeros(self) -> uint { @@ -117,7 +117,7 @@ pub trait Int /// /// assert_eq!(n.leading_zeros(), 10); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn leading_zeros(self) -> uint; @@ -133,7 +133,7 @@ pub trait Int /// /// assert_eq!(n.trailing_zeros(), 3); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn trailing_zeros(self) -> uint; @@ -150,7 +150,7 @@ pub trait Int /// /// assert_eq!(n.rotate_left(12), m); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn rotate_left(self, n: uint) -> Self; @@ -167,7 +167,7 @@ pub trait Int /// /// assert_eq!(n.rotate_right(12), m); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] fn rotate_right(self, n: uint) -> Self; @@ -368,7 +368,7 @@ pub trait Int /// /// assert_eq!(2i.pow(4), 16); /// ``` - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "pending integer conventions")] #[inline] fn pow(self, mut exp: uint) -> Self { @@ -632,7 +632,7 @@ pub trait SignedInt { /// Computes the absolute value of `self`. `Int::min_value()` will be /// returned if the number is `Int::min_value()`. - #[unstable(feature = "unnamed_feature", reason = "overflow in debug builds?")] + #[unstable(feature = "core", reason = "overflow in debug builds?")] fn abs(self) -> Self; /// Returns a number representing sign of `self`. @@ -737,7 +737,7 @@ impl UnsignedInt for u32 {} impl UnsignedInt for u64 {} /// A generic trait for converting a value to a number. -#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")] +#[unstable(feature = "core", reason = "trait is likely to be removed")] pub trait ToPrimitive { /// Converts the value of `self` to an `int`. #[inline] @@ -1002,7 +1002,7 @@ impl_to_primitive_float! { f32 } impl_to_primitive_float! { f64 } /// A generic trait for converting a number to a value. -#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")] +#[unstable(feature = "core", reason = "trait is likely to be removed")] pub trait FromPrimitive : ::marker::Sized { /// Convert an `int` to return an optional value of this type. If the /// value cannot be represented by this value, the `None` is returned. @@ -1084,73 +1084,73 @@ pub trait FromPrimitive : ::marker::Sized { } /// A utility function that just calls `FromPrimitive::from_int`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_int<A: FromPrimitive>(n: int) -> Option<A> { FromPrimitive::from_int(n) } /// A utility function that just calls `FromPrimitive::from_i8`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> { FromPrimitive::from_i8(n) } /// A utility function that just calls `FromPrimitive::from_i16`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> { FromPrimitive::from_i16(n) } /// A utility function that just calls `FromPrimitive::from_i32`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> { FromPrimitive::from_i32(n) } /// A utility function that just calls `FromPrimitive::from_i64`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> { FromPrimitive::from_i64(n) } /// A utility function that just calls `FromPrimitive::from_uint`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_uint<A: FromPrimitive>(n: uint) -> Option<A> { FromPrimitive::from_uint(n) } /// A utility function that just calls `FromPrimitive::from_u8`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> { FromPrimitive::from_u8(n) } /// A utility function that just calls `FromPrimitive::from_u16`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> { FromPrimitive::from_u16(n) } /// A utility function that just calls `FromPrimitive::from_u32`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> { FromPrimitive::from_u32(n) } /// A utility function that just calls `FromPrimitive::from_u64`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> { FromPrimitive::from_u64(n) } /// A utility function that just calls `FromPrimitive::from_f32`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> { FromPrimitive::from_f32(n) } /// A utility function that just calls `FromPrimitive::from_f64`. -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> { FromPrimitive::from_f64(n) } @@ -1201,13 +1201,13 @@ impl_from_primitive! { f64, to_f64 } /// ``` /// #[inline] -#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] +#[unstable(feature = "core", reason = "likely to be removed")] pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> { NumCast::from(n) } /// An interface for casting between machine scalars. -#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")] +#[unstable(feature = "core", reason = "trait is likely to be removed")] pub trait NumCast: ToPrimitive { /// Creates a number from another value that can be converted into a primitive via the /// `ToPrimitive` trait. @@ -1242,7 +1242,7 @@ impl_num_cast! { f64, to_f64 } /// Used for representing the classification of floating point numbers #[derive(Copy, PartialEq, Show)] -#[unstable(feature = "unnamed_feature", reason = "may be renamed")] +#[unstable(feature = "core", reason = "may be renamed")] pub enum FpCategory { /// "Not a Number", often obtained by dividing by zero Nan, @@ -1262,7 +1262,7 @@ pub enum FpCategory { // // FIXME(#8888): Several of these functions have a parameter named // `unused_self`. Removing it requires #8888 to be fixed. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "distribution of methods between core/std is unclear")] pub trait Float : Copy + Clone @@ -1418,20 +1418,20 @@ pub trait Float } /// A generic trait for converting a string with a radix (base) to a value -#[unstable(feature = "unnamed_feature", reason = "might need to return Result")] +#[unstable(feature = "core", reason = "might need to return Result")] pub trait FromStrRadix { fn from_str_radix(str: &str, radix: uint) -> Option<Self>; } /// A utility function that just calls FromStrRadix::from_str_radix. -#[unstable(feature = "unnamed_feature", reason = "might need to return Result")] +#[unstable(feature = "core", reason = "might need to return Result")] pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> { FromStrRadix::from_str_radix(str, radix) } macro_rules! from_str_radix_float_impl { ($T:ty) => { - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "might need to return Result")] impl FromStr for $T { /// Convert a string in base 10 to a float. @@ -1465,7 +1465,7 @@ macro_rules! from_str_radix_float_impl { } } - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "might need to return Result")] impl FromStrRadix for $T { /// Convert a string in a given base to a float. @@ -1630,7 +1630,7 @@ from_str_radix_float_impl! { f64 } macro_rules! from_str_radix_int_impl { ($T:ty) => { - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "might need to return Result")] impl FromStr for $T { #[inline] @@ -1639,7 +1639,7 @@ macro_rules! from_str_radix_int_impl { } } - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "might need to return Result")] impl FromStrRadix for $T { fn from_str_radix(src: &str, radix: uint) -> Option<$T> { diff --git a/src/libcore/num/uint_macros.rs b/src/libcore/num/uint_macros.rs index c584fc90557..c18333892d9 100644 --- a/src/libcore/num/uint_macros.rs +++ b/src/libcore/num/uint_macros.rs @@ -12,9 +12,9 @@ macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => ( -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub const BITS : uint = $bits; -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub const BYTES : uint = ($bits / 8); #[stable(feature = "grandfathered", since = "1.0.0")] diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index 17ba135eb7c..1ba4f629390 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -108,7 +108,7 @@ pub trait Drop { // based on "op T" where T is expected to be `Copy`able macro_rules! forward_ref_unop { (impl $imp:ident, $method:ident for $t:ty) => { - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added, waiting for dust to settle")] impl<'a> $imp for &'a $t { type Output = <$t as $imp>::Output; @@ -125,7 +125,7 @@ macro_rules! forward_ref_unop { // based on "T op U" where T and U are expected to be `Copy`able macro_rules! forward_ref_binop { (impl $imp:ident, $method:ident for $t:ty, $u:ty) => { - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added, waiting for dust to settle")] impl<'a> $imp<$u> for &'a $t { type Output = <$t as $imp<$u>>::Output; @@ -136,7 +136,7 @@ macro_rules! forward_ref_binop { } } - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added, waiting for dust to settle")] impl<'a> $imp<&'a $u> for $t { type Output = <$t as $imp<$u>>::Output; @@ -147,7 +147,7 @@ macro_rules! forward_ref_binop { } } - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added, waiting for dust to settle")] impl<'a, 'b> $imp<&'a $u> for &'b $t { type Output = <$t as $imp<$u>>::Output; @@ -974,10 +974,10 @@ pub trait IndexMut<Index: ?Sized> { /// An unbounded range. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="full_range"] -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] pub struct FullRange; -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl fmt::Show for FullRange { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt::Show::fmt("..", fmt) @@ -987,7 +987,7 @@ impl fmt::Show for FullRange { /// A (half-open) range which is bounded at both ends. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="range"] -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] pub struct Range<Idx> { /// The lower bound of the range (inclusive). pub start: Idx, @@ -995,7 +995,7 @@ pub struct Range<Idx> { pub end: Idx, } -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl<Idx: Clone + Step> Iterator for Range<Idx> { type Item = Idx; @@ -1020,7 +1020,7 @@ impl<Idx: Clone + Step> Iterator for Range<Idx> { } } -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> { #[inline] fn next_back(&mut self) -> Option<Idx> { @@ -1033,10 +1033,10 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> { } } -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {} -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl<Idx: fmt::Show> fmt::Show for Range<Idx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "{:?}..{:?}", self.start, self.end) @@ -1046,13 +1046,13 @@ impl<Idx: fmt::Show> fmt::Show for Range<Idx> { /// A range which is only bounded below. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="range_from"] -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] pub struct RangeFrom<Idx> { /// The lower bound of the range (inclusive). pub start: Idx, } -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> { type Item = Idx; @@ -1065,7 +1065,7 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> { } } -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "{:?}..", self.start) @@ -1075,13 +1075,13 @@ impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> { /// A range which is only bounded above. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="range_to"] -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] pub struct RangeTo<Idx> { /// The upper bound of the range (exclusive). pub end: Idx, } -#[unstable(feature = "unnamed_feature", reason = "API still in development")] +#[unstable(feature = "core", reason = "API still in development")] impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "..{:?}", self.end) @@ -1196,7 +1196,7 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T { /// A version of the call operator that takes an immutable receiver. #[lang="fn"] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "uncertain about variadic generics, input versus associated types")] pub trait Fn<Args,Result> { /// This is called when the call operator is used. @@ -1205,7 +1205,7 @@ pub trait Fn<Args,Result> { /// A version of the call operator that takes a mutable receiver. #[lang="fn_mut"] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "uncertain about variadic generics, input versus associated types")] pub trait FnMut<Args,Result> { /// This is called when the call operator is used. @@ -1214,7 +1214,7 @@ pub trait FnMut<Args,Result> { /// A version of the call operator that takes a by-value receiver. #[lang="fn_once"] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "uncertain about variadic generics, input versus associated types")] pub trait FnOnce<Args,Result> { /// This is called when the call operator is used. diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 7b8e1ebd7b8..8e27c039aa2 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -285,7 +285,7 @@ impl<T> Option<T> { /// assert_eq!(x, Some("Dirt")); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "waiting for mut conventions")] pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] { match *self { @@ -477,7 +477,7 @@ impl<T> Option<T> { /// assert_eq!(x.ok_or(0i), Err(0i)); /// ``` #[inline] - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub fn ok_or<E>(self, err: E) -> Result<T, E> { match self { Some(v) => Ok(v), @@ -498,7 +498,7 @@ impl<T> Option<T> { /// assert_eq!(x.ok_or_else(|| 0i), Err(0i)); /// ``` #[inline] - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> { match self { Some(v) => Ok(v), @@ -543,7 +543,7 @@ impl<T> Option<T> { /// assert_eq!(x.iter_mut().next(), None); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "waiting for iterator conventions")] pub fn iter_mut(&mut self) -> IterMut<T> { IterMut { inner: Item { opt: self.as_mut() } } @@ -704,7 +704,7 @@ impl<T> Option<T> { impl<'a, T: Clone, D: Deref<Target=T>> Option<D> { /// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option. /// Useful for converting an Option<&T> to an Option<T>. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added as part of collections reform")] pub fn cloned(self) -> Option<T> { self.map(|t| t.deref().clone()) @@ -748,7 +748,7 @@ impl<T: Default> Option<T> { // Trait implementations ///////////////////////////////////////////////////////////////////////////// -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "waiting on the stability of the trait itself")] impl<T> AsSlice<T> for Option<T> { /// Convert from `Option<T>` to `&[T]` (without copying) diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index a66ea639668..9b6d5bfc71f 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -99,13 +99,13 @@ use cmp::Ordering::{self, Less, Equal, Greater}; // FIXME #19649: intrinsic docs don't render, so these have no docs :( -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub use intrinsics::copy_nonoverlapping_memory; -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub use intrinsics::copy_memory; -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "uncertain about naming and semantics")] pub use intrinsics::set_memory; @@ -146,7 +146,7 @@ pub fn null_mut<T>() -> *mut T { 0 as *mut T } /// Beyond accepting a raw pointer, this is unsafe because it will not drop the /// contents of `dst`, and may be used to create invalid instances of `T`. #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "may play a larger role in std::ptr future extensions")] pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) { set_memory(dst, 0, count); @@ -215,7 +215,7 @@ pub unsafe fn read<T>(src: *const T) -> T { /// /// This is unsafe for the same reasons that `read` is unsafe. #[inline(always)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "may play a larger role in std::ptr future extensions")] pub unsafe fn read_and_zero<T>(dest: *mut T) -> T { // Copy the data out from `dest`: @@ -262,7 +262,7 @@ pub trait PtrExt: Sized { /// null-safety, it is important to note that this is still an unsafe /// operation because the returned value could be pointing to invalid /// memory. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "Option is not clearly the right return type, and we may want \ to tie the return lifetime to a borrow of the raw pointer")] unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>; @@ -291,7 +291,7 @@ pub trait MutPtrExt { /// /// As with `as_ref`, this is unsafe because it cannot verify the validity /// of the returned pointer. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "Option is not clearly the right return type, and we may want \ to tie the return lifetime to a borrow of the raw pointer")] unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>; @@ -312,7 +312,7 @@ impl<T> PtrExt for *const T { } #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "return value does not necessarily convey all possible \ information")] unsafe fn as_ref<'a>(&self) -> Option<&'a T> { @@ -339,7 +339,7 @@ impl<T> PtrExt for *mut T { } #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "return value does not necessarily convey all possible \ information")] unsafe fn as_ref<'a>(&self) -> Option<&'a T> { @@ -356,7 +356,7 @@ impl<T> MutPtrExt for *mut T { type Target = T; #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "return value does not necessarily convey all possible \ information")] unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> { @@ -521,33 +521,33 @@ impl<T> PartialOrd for *mut T { /// raw `*mut T` (which conveys no particular ownership semantics). /// Useful for building abstractions like `Vec<T>` or `Box<T>`, which /// internally use raw pointers to manage the memory that they own. -#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] +#[unstable(feature = "core", reason = "recently added to this module")] pub struct Unique<T>(pub *mut T); /// `Unique` pointers are `Send` if `T` is `Send` because the data they /// reference is unaliased. Note that this aliasing invariant is /// unenforced by the type system; the abstraction using the /// `Unique` must enforce it. -#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] +#[unstable(feature = "core", reason = "recently added to this module")] unsafe impl<T:Send> Send for Unique<T> { } /// `Unique` pointers are `Sync` if `T` is `Sync` because the data they /// reference is unaliased. Note that this aliasing invariant is /// unenforced by the type system; the abstraction using the /// `Unique` must enforce it. -#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] +#[unstable(feature = "core", reason = "recently added to this module")] unsafe impl<T:Sync> Sync for Unique<T> { } impl<T> Unique<T> { /// Returns a null Unique. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added to this module")] pub fn null() -> Unique<T> { Unique(null_mut()) } /// Return an (unsafe) pointer into the memory owned by `self`. - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "recently added to this module")] pub unsafe fn offset(self, offset: int) -> *mut T { self.0.offset(offset) diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 02d2d29ade1..3fd244b46e3 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(missing_docs)] -#![unstable(feature = "unnamed_feature")] +#![unstable(feature = "core")] //! Contains struct definitions for the layout of compiler built-in types. //! diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 51119b2fc03..2965cf71c18 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -417,7 +417,7 @@ impl<T, E> Result<T, E> { /// assert!(x.as_mut_slice().is_empty()); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", + #[unstable(feature = "core", reason = "waiting for mut conventions")] pub fn as_mut_slice(&mut self) -> &mut [T] { match *self { @@ -950,7 +950,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> { /// If an `Err` is encountered, it is immediately returned. /// Otherwise, the folded value is returned. #[inline] -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub fn fold<T, V, E, diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs index 086fff58910..4a1c123668f 100644 --- a/src/libcore/simd.rs +++ b/src/libcore/simd.rs @@ -36,7 +36,7 @@ #![allow(non_camel_case_types)] #![allow(missing_docs)] -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -45,26 +45,26 @@ pub struct i8x16(pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i16x8(pub i16, pub i16, pub i16, pub i16, pub i16, pub i16, pub i16, pub i16); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i32x4(pub i32, pub i32, pub i32, pub i32); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i64x2(pub i64, pub i64); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -73,32 +73,32 @@ pub struct u8x16(pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u16x8(pub u16, pub u16, pub u16, pub u16, pub u16, pub u16, pub u16, pub u16); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u32x4(pub u32, pub u32, pub u32, pub u32); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u64x2(pub u64, pub u64); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct f32x4(pub f32, pub f32, pub f32, pub f32); -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] #[simd] #[derive(Copy, Show)] #[repr(C)] diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 779ace7a613..7095fa319d0 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -131,7 +131,7 @@ pub trait SliceExt { fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<T> SliceExt for [T] { type Item = T; @@ -258,7 +258,7 @@ impl<T> SliceExt for [T] { self.repr().data } - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] fn binary_search_by<F>(&self, mut f: F) -> Result<uint, uint> where F: FnMut(&T) -> Ordering { @@ -452,12 +452,12 @@ impl<T> SliceExt for [T] { m >= n && needle == &self[(m-n)..] } - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord { self.binary_search_by(|p| p.cmp(x)) } - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] fn next_permutation(&mut self) -> bool where T: Ord { // These cases only have 1 permutation each, so we can't do anything. if self.len() < 2 { return false; } @@ -488,7 +488,7 @@ impl<T> SliceExt for [T] { true } - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] fn prev_permutation(&mut self) -> bool where T: Ord { // These cases only have 1 permutation each, so we can't do anything. if self.len() < 2 { return false; } @@ -630,26 +630,26 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] { //////////////////////////////////////////////////////////////////////////////// /// Data that is viewable as a slice. -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will be replaced by slice syntax")] pub trait AsSlice<T> { /// Work with `self` as a slice. fn as_slice<'a>(&'a self) -> &'a [T]; } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<T> AsSlice<T> for [T] { #[inline(always)] fn as_slice<'a>(&'a self) -> &'a [T] { self } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U { #[inline(always)] fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U { #[inline(always)] fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } @@ -755,7 +755,7 @@ pub struct Iter<'a, T: 'a> { marker: marker::ContravariantLifetime<'a> } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -764,7 +764,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -773,7 +773,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -782,7 +782,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> { type Output = [T]; #[inline] @@ -796,7 +796,7 @@ impl<'a, T> Iter<'a, T> { /// /// This has the same lifetime as the original slice, and so the /// iterator can continue to be used while this exists. - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub fn as_slice(&self) -> &'a [T] { make_slice!(T => &'a [T]: self.ptr, self.end) } @@ -814,7 +814,7 @@ impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Iter<'a, T> { *self } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<'a, T> RandomAccessIterator for Iter<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -848,7 +848,7 @@ pub struct IterMut<'a, T: 'a> { } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -856,7 +856,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -864,7 +864,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -872,7 +872,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -881,7 +881,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -889,7 +889,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -897,7 +897,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -905,7 +905,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -922,7 +922,7 @@ impl<'a, T> IterMut<'a, T> { /// to consume the iterator. Consider using the `Slice` and /// `SliceMut` implementations for obtaining slices with more /// restricted lifetimes that do not consume the iterator. - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] pub fn into_slice(self) -> &'a mut [T] { make_slice!(T => &'a mut [T]: self.ptr, self.end) } @@ -1270,7 +1270,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> { } } -#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] +#[unstable(feature = "core", reason = "trait is experimental")] impl<'a, T> RandomAccessIterator for Chunks<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -1354,7 +1354,7 @@ impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> { // /// Converts a pointer to A into a slice of length 1 (without copying). -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] { unsafe { transmute(RawSlice { data: s, len: 1 }) @@ -1362,7 +1362,7 @@ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] { } /// Converts a pointer to A into a slice of length 1 (without copying). -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { unsafe { let ptr: *const A = transmute(s); @@ -1396,7 +1396,7 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { /// } /// ``` #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "should be renamed to from_raw_parts")] pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] { transmute(RawSlice { data: *p, len: len }) @@ -1409,7 +1409,7 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] { /// not being able to provide a non-aliasing guarantee of the returned mutable /// slice. #[inline] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "should be renamed to from_raw_parts_mut")] pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { transmute(RawSlice { data: *p, len: len }) @@ -1420,7 +1420,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { // /// Operations on `[u8]`. -#[unstable(feature = "unnamed_feature", reason = "needs review")] +#[unstable(feature = "core", reason = "needs review")] pub mod bytes { use ptr; use slice::SliceExt; @@ -1508,7 +1508,7 @@ impl<T: PartialOrd> PartialOrd for [T] { } /// Extension methods for slices containing integers. -#[unstable(feature = "unnamed_feature")] +#[unstable(feature = "core")] pub trait IntSliceExt<U, S> { /// Converts the slice to an immutable slice of unsigned integers with the same width. fn as_unsigned<'a>(&'a self) -> &'a [U]; @@ -1523,7 +1523,7 @@ pub trait IntSliceExt<U, S> { macro_rules! impl_int_slice { ($u:ty, $s:ty, $t:ty) => { - #[unstable(feature = "unnamed_feature")] + #[unstable(feature = "core")] impl IntSliceExt<$u, $s> for [$t] { #[inline] fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } } diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 2086d727053..8daf71edb33 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -108,7 +108,7 @@ macro_rules! delegate_iter { /// A trait to abstract the idea of creating a new instance of a type from a /// string. // FIXME(#17307): there should be an `E` associated type for a `Result` return -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "will return a Result once associated types are working")] pub trait FromStr { /// Parses a string `s` to return an optional value of this type. If the @@ -144,7 +144,7 @@ Section: Creating a string /// Errors which can occur when attempting to interpret a byte slice as a `str`. #[derive(Copy, Eq, PartialEq, Clone, Show)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "error enumeration recently added and definitions may be refined")] pub enum Utf8Error { /// An invalid byte was detected at the byte offset given. @@ -208,7 +208,7 @@ pub unsafe fn from_c_str(s: *const i8) -> &'static str { } /// Something that can be used to compare against a character -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "definition may change as pattern-related methods are stabilized")] pub trait CharEq { /// Determine if the splitter should split at the given character @@ -861,7 +861,7 @@ impl Searcher { /// An iterator over the start and end indices of the matches of a /// substring within a larger string #[derive(Clone)] -#[unstable(feature = "unnamed_feature", reason = "type may be removed")] +#[unstable(feature = "core", reason = "type may be removed")] pub struct MatchIndices<'a> { // constants haystack: &'a str, @@ -872,7 +872,7 @@ pub struct MatchIndices<'a> { /// An iterator over the substrings of a string separated by a given /// search string #[derive(Clone)] -#[unstable(feature = "unnamed_feature", reason = "type may be removed")] +#[unstable(feature = "core", reason = "type may be removed")] pub struct SplitStr<'a> { it: MatchIndices<'a>, last_end: uint, @@ -1056,7 +1056,7 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [ /// the next `char` in a string. This can be used as a data structure /// for iterating over the UTF-8 bytes of a string. #[derive(Copy)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "naming is uncertain with container conventions")] pub struct CharRange { /// Current `char` @@ -1151,7 +1151,7 @@ mod traits { } /// Any string that can be represented as a slice -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "Instead of taking this bound generically, this trait will be \ replaced with one of slicing syntax, deref coercions, or \ a more generic conversion trait")] @@ -1178,7 +1178,7 @@ delegate_iter!{pattern &'a str : Split<'a, P>} /// Return type of `StrExt::split_terminator` #[derive(Clone)] -#[unstable(feature = "unnamed_feature", +#[unstable(feature = "core", reason = "might get removed in favour of a constructor method on Split")] pub struct SplitTerminator<'a, P>(CharSplits<'a, P>); delegate_iter!{pattern &'a str : SplitTerminator<'a, P>} |