std: Stabilize unit, bool, ty, tuple, arc, any

This commit applies stability attributes to the contents of these modules,
summarized here:

* The `unit` and `bool` modules have become #[unstable] as they are purely meant
  for documentation purposes and are candidates for removal.

* The `ty` module has been deprecated, and the inner `Unsafe` type has been
  renamed to `UnsafeCell` and moved to the `cell` module. The `marker1` field
  has been removed as the compiler now always infers `UnsafeCell` to be
  invariant. The `new` method i stable, but the `value` field, `get` and
  `unwrap` methods are all unstable.

* The `tuple` module has its name as stable, the naming of the `TupleN` traits
  as stable while the methods are all #[unstable]. The other impls in the module
  have appropriate stability for the corresponding trait.

* The `arc` module has received the exact same treatment as the `rc` module
  previously did.

* The `any` module has its name as stable. The `Any` trait is also stable, with
  a new private supertrait which now contains the `get_type_id` method. This is
  to make the method a private implementation detail rather than a public-facing
  detail.

  The two extension traits in the module are marked #[unstable] as they will not
  be necessary with DST. The `is` method is #[stable], the as_{mut,ref} methods
  have been renamed to downcast_{mut,ref} and are #[unstable].

  The extension trait `BoxAny` has been clarified as to why it is unstable as it
  will not be necessary with DST.

This is a breaking change because the `marker1` field was removed from the
`UnsafeCell` type. To deal with this change, you can simply delete the field and
only specify the value of the `data` field in static initializers.

[breaking-change]

src/liballoc/arc.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*!
- * Concurrency-enabled mechanisms for sharing mutable and/or immutable state
- * between tasks.
- */
+#![stable]
+
+//! Concurrency-enabled mechanisms for sharing mutable and/or immutable state
+//! between tasks.
 
 use core::atomics;
 use core::clone::Clone;
@@ -51,6 +51,7 @@ use heap::deallocate;
 /// }
 /// ```
 #[unsafe_no_drop_flag]
+#[stable]
 pub struct Arc<T> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
@@ -62,6 +63,7 @@ pub struct Arc<T> {
 /// Weak pointers will not keep the data inside of the `Arc` alive, and can be
 /// used to break cycles between `Arc` pointers.
 #[unsafe_no_drop_flag]
+#[experimental = "Weak pointers may not belong in this module."]
 pub struct Weak<T> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
@@ -77,6 +79,7 @@ struct ArcInner<T> {
 impl<T: Share + Send> Arc<T> {
     /// Create an atomically reference counted wrapper.
     #[inline]
+    #[stable]
     pub fn new(data: T) -> Arc<T> {
         // Start the weak pointer count as 1 which is the weak pointer that's
         // held by all the strong pointers (kinda), see std/rc.rs for more info
@@ -103,14 +106,15 @@ impl<T: Share + Send> Arc<T> {
     /// Weak pointers will not keep the data alive. Once all strong references
     /// to the underlying data have been dropped, the data itself will be
     /// destroyed.
+    #[experimental = "Weak pointers may not belong in this module."]
     pub fn downgrade(&self) -> Weak<T> {
         // See the clone() impl for why this is relaxed
         self.inner().weak.fetch_add(1, atomics::Relaxed);
         Weak { _ptr: self._ptr }
     }
 }
 
-#[unstable]
+#[unstable = "waiting on stability of Clone"]
 impl<T: Share + Send> Clone for Arc<T> {
     /// Duplicate an atomically reference counted wrapper.
     ///
@@ -135,6 +139,7 @@ impl<T: Share + Send> Clone for Arc<T> {
     }
 }
 
+#[experimental = "Deref is experimental."]
 impl<T: Send + Share> Deref<T> for Arc<T> {
     #[inline]
     fn deref<'a>(&'a self) -> &'a T {
@@ -169,6 +174,7 @@ impl<T: Send + Share + Clone> Arc<T> {
 }
 
 #[unsafe_destructor]
+#[experimental = "waiting on stability of Drop"]
 impl<T: Share + Send> Drop for Arc<T> {
     fn drop(&mut self) {
         // This structure has #[unsafe_no_drop_flag], so this drop glue may run
@@ -212,6 +218,7 @@ impl<T: Share + Send> Drop for Arc<T> {
     }
 }
 
+#[experimental = "Weak pointers may not belong in this module."]
 impl<T: Share + Send> Weak<T> {
     /// Attempts to upgrade this weak reference to a strong reference.
     ///
@@ -237,7 +244,7 @@ impl<T: Share + Send> Weak<T> {
     }
 }
 
-#[unstable]
+#[experimental = "Weak pointers may not belong in this module."]
 impl<T: Share + Send> Clone for Weak<T> {
     #[inline]
     fn clone(&self) -> Weak<T> {
@@ -248,6 +255,7 @@ impl<T: Share + Send> Clone for Weak<T> {
 }
 
 #[unsafe_destructor]
+#[experimental = "Weak pointers may not belong in this module."]
 impl<T: Share + Send> Drop for Weak<T> {
     fn drop(&mut self) {
         // see comments above for why this check is here

src/liballoc/boxed.rs

@@ -87,10 +87,12 @@ impl<T: Ord> Ord for Box<T> {
 impl<T: Eq> Eq for Box<T> {}
 
 /// Extension methods for an owning `Any` trait object
-#[unstable = "post-DST, the signature of `downcast` will change to take `Box<Self>`"]
+#[unstable = "post-DST and coherence changes, this will not be a trait but \
+              rather a direct `impl` on `Box<Any>`"]
 pub trait BoxAny {
     /// Returns the boxed value if it is of type `T`, or
     /// `Err(Self)` if it isn't.
+    #[unstable = "naming conventions around accessing innards may change"]
     fn downcast<T: 'static>(self) -> Result<Box<T>, Self>;
 
     /// Deprecated; this method has been renamed to `downcast`.
@@ -100,6 +102,7 @@ pub trait BoxAny {
     }
 }
 
+#[stable]
 impl BoxAny for Box<Any> {
     #[inline]
     fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {

src/liballoc/rc.rs

@@ -379,7 +379,6 @@ impl<T> Drop for Weak<T> {
     }
 }
 
-#[unstable]
 #[experimental = "Weak pointers may not belong in this module."]
 impl<T> Clone for Weak<T> {
     #[inline]

src/libcore/any.rs

@@ -44,7 +44,7 @@
 //!     // try to convert our value to a String.  If successful, we want to
 //!     // output the String's length as well as its value.  If not, it's a
 //!     // different type: just print it out unadorned.
-//!     match value_any.as_ref::<String>() {
+//!     match value_any.downcast_ref::<String>() {
 //!         Some(as_string) => {
 //!             println!("String ({}): {}", as_string.len(), as_string);
 //!         }
@@ -69,51 +69,72 @@
 //! }
 //! ```
 
+#![stable]
+
 use mem::{transmute, transmute_copy};
 use option::{Option, Some, None};
 use raw::TraitObject;
 use intrinsics::TypeId;
 
 /// A type with no inhabitants
+#[deprecated = "this type is being removed, define a type locally if \
+                necessary"]
 pub enum Void { }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Any trait
 ///////////////////////////////////////////////////////////////////////////////
 
-/// The `Any` trait is implemented by all `'static` types, and can be used for dynamic typing
+/// The `Any` trait is implemented by all `'static` types, and can be used for
+/// dynamic typing
 ///
-/// Every type with no non-`'static` references implements `Any`, so `Any` can be used as a trait
-/// object to emulate the effects dynamic typing.
-pub trait Any {
+/// Every type with no non-`'static` references implements `Any`, so `Any` can
+/// be used as a trait object to emulate the effects dynamic typing.
+#[stable]
+pub trait Any: AnyPrivate {}
+
+/// An inner trait to ensure that only this module can call `get_type_id()`.
+trait AnyPrivate {
     /// Get the `TypeId` of `self`
     fn get_type_id(&self) -> TypeId;
 }
 
-impl<T: 'static> Any for T {
-    /// Get the `TypeId` of `self`
-    fn get_type_id(&self) -> TypeId {
-        TypeId::of::<T>()
-    }
+impl<T: 'static> AnyPrivate for T {
+    fn get_type_id(&self) -> TypeId { TypeId::of::<T>() }
 }
 
+impl<T: 'static + AnyPrivate> Any for T {}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Extension methods for Any trait objects.
 // Implemented as three extension traits so that the methods can be generic.
 ///////////////////////////////////////////////////////////////////////////////
 
 /// Extension methods for a referenced `Any` trait object
+#[unstable = "this trait will not be necessary once DST lands, it will be a \
+              part of `impl Any`"]
 pub trait AnyRefExt<'a> {
     /// Returns true if the boxed type is the same as `T`
+    #[stable]
     fn is<T: 'static>(self) -> bool;
 
     /// Returns some reference to the boxed value if it is of type `T`, or
     /// `None` if it isn't.
-    fn as_ref<T: 'static>(self) -> Option<&'a T>;
+    #[unstable = "naming conventions around acquiring references may change"]
+    fn downcast_ref<T: 'static>(self) -> Option<&'a T>;
+
+    /// Returns some reference to the boxed value if it is of type `T`, or
+    /// `None` if it isn't.
+    #[deprecated = "this function has been renamed to `downcast_ref`"]
+    fn as_ref<T: 'static>(self) -> Option<&'a T> {
+        self.downcast_ref::<T>()
+    }
 }
 
+#[stable]
 impl<'a> AnyRefExt<'a> for &'a Any {
     #[inline]
+    #[stable]
     fn is<T: 'static>(self) -> bool {
         // Get TypeId of the type this function is instantiated with
         let t = TypeId::of::<T>();
@@ -126,7 +147,8 @@ impl<'a> AnyRefExt<'a> for &'a Any {
     }
 
     #[inline]
-    fn as_ref<T: 'static>(self) -> Option<&'a T> {
+    #[unstable = "naming conventions around acquiring references may change"]
+    fn downcast_ref<T: 'static>(self) -> Option<&'a T> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
@@ -142,15 +164,27 @@ impl<'a> AnyRefExt<'a> for &'a Any {
 }
 
 /// Extension methods for a mutable referenced `Any` trait object
+#[unstable = "this trait will not be necessary once DST lands, it will be a \
+              part of `impl Any`"]
 pub trait AnyMutRefExt<'a> {
     /// Returns some mutable reference to the boxed value if it is of type `T`, or
     /// `None` if it isn't.
-    fn as_mut<T: 'static>(self) -> Option<&'a mut T>;
+    #[unstable = "naming conventions around acquiring references may change"]
+    fn downcast_mut<T: 'static>(self) -> Option<&'a mut T>;
+
+    /// Returns some mutable reference to the boxed value if it is of type `T`, or
+    /// `None` if it isn't.
+    #[deprecated = "this function has been renamed to `downcast_mut`"]
+    fn as_mut<T: 'static>(self) -> Option<&'a mut T> {
+        self.downcast_mut::<T>()
+    }
 }
 
+#[stable]
 impl<'a> AnyMutRefExt<'a> for &'a mut Any {
     #[inline]
-    fn as_mut<T: 'static>(self) -> Option<&'a mut T> {
+    #[unstable = "naming conventions around acquiring references may change"]
+    fn downcast_mut<T: 'static>(self) -> Option<&'a mut T> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object

src/libcore/atomics.rs

@@ -12,29 +12,29 @@
 
 use intrinsics;
 use std::kinds::marker;
-use ty::Unsafe;
+use cell::UnsafeCell;
 
 /// An atomic boolean type.
 pub struct AtomicBool {
-    v: Unsafe<uint>,
+    v: UnsafeCell<uint>,
     nocopy: marker::NoCopy
 }
 
 /// A signed atomic integer type, supporting basic atomic arithmetic operations
 pub struct AtomicInt {
-    v: Unsafe<int>,
+    v: UnsafeCell<int>,
     nocopy: marker::NoCopy
 }
 
 /// An unsigned atomic integer type, supporting basic atomic arithmetic operations
 pub struct AtomicUint {
-    v: Unsafe<uint>,
+    v: UnsafeCell<uint>,
     nocopy: marker::NoCopy
 }
 
 /// An unsafe atomic pointer. Only supports basic atomic operations
 pub struct AtomicPtr<T> {
-    p: Unsafe<uint>,
+    p: UnsafeCell<uint>,
     nocopy: marker::NoCopy
 }
 
@@ -69,17 +69,14 @@ pub enum Ordering {
 }
 
 /// An `AtomicBool` initialized to `false`
-pub static INIT_ATOMIC_BOOL : AtomicBool = AtomicBool { v: Unsafe{value: 0,
-                                                                  marker1: marker::InvariantType},
-                                                        nocopy: marker::NoCopy };
+pub static INIT_ATOMIC_BOOL: AtomicBool =
+        AtomicBool { v: UnsafeCell { value: 0 }, nocopy: marker::NoCopy };
 /// An `AtomicInt` initialized to `0`
-pub static INIT_ATOMIC_INT  : AtomicInt  = AtomicInt  { v: Unsafe{value: 0,
-                                                                  marker1: marker::InvariantType},
-                                                        nocopy: marker::NoCopy };
+pub static INIT_ATOMIC_INT: AtomicInt =
+        AtomicInt { v: UnsafeCell { value: 0 }, nocopy: marker::NoCopy };
 /// An `AtomicUint` initialized to `0`
-pub static INIT_ATOMIC_UINT : AtomicUint = AtomicUint { v: Unsafe{value: 0,
-                                                                  marker1: marker::InvariantType},
-                                                        nocopy: marker::NoCopy };
+pub static INIT_ATOMIC_UINT: AtomicUint =
+        AtomicUint { v: UnsafeCell { value: 0, }, nocopy: marker::NoCopy };
 
 // NB: Needs to be -1 (0b11111111...) to make fetch_nand work correctly
 static UINT_TRUE: uint = -1;
@@ -88,7 +85,7 @@ impl AtomicBool {
     /// Create a new `AtomicBool`
     pub fn new(v: bool) -> AtomicBool {
         let val = if v { UINT_TRUE } else { 0 };
-        AtomicBool { v: Unsafe::new(val), nocopy: marker::NoCopy }
+        AtomicBool { v: UnsafeCell::new(val), nocopy: marker::NoCopy }
     }
 
     /// Load the value
@@ -289,7 +286,7 @@ impl AtomicBool {
 impl AtomicInt {
     /// Create a new `AtomicInt`
     pub fn new(v: int) -> AtomicInt {
-        AtomicInt {v: Unsafe::new(v), nocopy: marker::NoCopy}
+        AtomicInt {v: UnsafeCell::new(v), nocopy: marker::NoCopy}
     }
 
     /// Load the value
@@ -401,7 +398,7 @@ impl AtomicInt {
 impl AtomicUint {
     /// Create a new `AtomicUint`
     pub fn new(v: uint) -> AtomicUint {
-        AtomicUint { v: Unsafe::new(v), nocopy: marker::NoCopy }
+        AtomicUint { v: UnsafeCell::new(v), nocopy: marker::NoCopy }
     }
 
     /// Load the value
@@ -513,7 +510,7 @@ impl AtomicUint {
 impl<T> AtomicPtr<T> {
     /// Create a new `AtomicPtr`
     pub fn new(p: *mut T) -> AtomicPtr<T> {
-        AtomicPtr { p: Unsafe::new(p as uint), nocopy: marker::NoCopy }
+        AtomicPtr { p: UnsafeCell::new(p as uint), nocopy: marker::NoCopy }
     }
 
     /// Load the value

src/libcore/bool.rs

@@ -11,4 +11,6 @@
 //! The boolean type
 
 #![doc(primitive = "bool")]
+#![unstable = "this module is purely for documentation and it will likely be \
+               removed from the public api"]