---

yaml
---
r: 153395
b: refs/heads/try2
c: b1a964a
h: refs/heads/master
i:
  153393: b39fe39
  153391: 42163e2
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: ffd9966c79ad034fe16e66e6c6795473473a6f50
+refs/heads/try2: b1a964a9bf23c92a6b6cb5762b54e0f0f4a337d5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/liballoc/lib.rs

@@ -21,11 +21,11 @@
 //!
 //! Currently, there are four major definitions in this library.
 //!
-//! ## Boxed values
+//! ## Owned pointers
 //!
-//! The [`Box`](boxed/index.html) type is the core owned pointer type in rust.
+//! The [`Box`](owned/index.html) type is the core owned pointer type in rust.
 //! There can only be one owner of a `Box`, and the owner can decide to mutate
-//! the contents, which live on the heap.
+//! the contents.
 //!
 //! This type can be sent among tasks efficiently as the size of a `Box` value
 //! is just a pointer. Tree-like data structures are often built on owned
@@ -82,12 +82,6 @@ extern crate libc;
 #[cfg(test)] #[phase(plugin, link)] extern crate std;
 #[cfg(test)] #[phase(plugin, link)] extern crate log;
 
-// The deprecated name of the boxed module
-
-#[deprecated = "use boxed instead"]
-#[cfg(not(test))]
-pub use owned = boxed;
-
 // Heaps provided for low-level allocation strategies
 
 pub mod heap;
@@ -97,7 +91,7 @@ pub mod util;
 // Primitive types using the heaps above
 
 #[cfg(not(test))]
-pub mod boxed;
+pub mod owned;
 pub mod arc;
 pub mod rc;
 

branches/try2/src/liballoc/boxed.rs renamed to branches/try2/src/liballoc/owned.rs

@@ -16,6 +16,7 @@ use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
 use core::default::Default;
 use core::fmt;
 use core::intrinsics;
+use core::kinds::Send;
 use core::mem;
 use core::option::Option;
 use core::raw::TraitObject;
@@ -26,19 +27,17 @@ use core::result::{Ok, Err, Result};
 ///
 /// The following two examples are equivalent:
 ///
-///     use std::boxed::HEAP;
+///     use std::owned::HEAP;
 ///
 ///     # struct Bar;
 ///     # impl Bar { fn new(_a: int) { } }
 ///     let foo = box(HEAP) Bar::new(2);
 ///     let foo = box Bar::new(2);
-#[lang = "exchange_heap"]
-#[experimental = "may be renamed; uncertain about custom allocator design"]
+#[lang="exchange_heap"]
 pub static HEAP: () = ();
 
 /// A type that represents a uniquely-owned value.
-#[lang = "owned_box"]
-#[unstable = "custom allocators will add an additional type parameter (with default)"]
+#[lang="owned_box"]
 pub struct Box<T>(*mut T);
 
 impl<T: Default> Default for Box<T> {
@@ -58,6 +57,7 @@ impl<T: Clone> Clone for Box<T> {
     }
 }
 
+// box pointers
 impl<T:PartialEq> PartialEq for Box<T> {
     #[inline]
     fn eq(&self, other: &Box<T>) -> bool { *(*self) == *(*other) }
@@ -85,27 +85,48 @@ 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>`"]
-pub trait BoxAny {
+pub trait AnyOwnExt {
     /// Returns the boxed value if it is of type `T`, or
     /// `Err(Self)` if it isn't.
-    fn downcast<T: 'static>(self) -> Result<Box<T>, Self>;
+    fn move<T: 'static>(self) -> Result<Box<T>, Self>;
+}
+
+impl AnyOwnExt for Box<Any> {
+    #[inline]
+    fn move<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
+        if self.is::<T>() {
+            unsafe {
+                // Get the raw representation of the trait object
+                let to: TraitObject =
+                    *mem::transmute::<&Box<Any>, &TraitObject>(&self);
+
+                // Prevent destructor on self being run
+                intrinsics::forget(self);
 
-    /// Deprecated; this method has been renamed to `downcast`.
-    #[deprecated = "use downcast instead"]
-    fn move<T: 'static>(self) -> Result<Box<T>, Self> {
-        self.downcast::<T>()
+                // Extract the data pointer
+                Ok(mem::transmute(to.data))
+            }
+        } else {
+            Err(self)
+        }
     }
 }
 
-impl BoxAny for Box<Any> {
+/// Extension methods for an owning `Any+Send` trait object
+pub trait AnySendOwnExt {
+    /// Returns the boxed value if it is of type `T`, or
+    /// `Err(Self)` if it isn't.
+    fn move_send<T: 'static>(self) -> Result<Box<T>, Self>;
+}
+
+impl AnySendOwnExt for Box<Any+Send> {
     #[inline]
-    fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
+    fn move_send<T: 'static>(self) -> Result<Box<T>, Box<Any+Send>> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
                 let to: TraitObject =
-                    *mem::transmute::<&Box<Any>, &TraitObject>(&self);
+                    *mem::transmute::<&Box<Any+Send>, &TraitObject>(&self);
 
                 // Prevent destructor on self being run
                 intrinsics::forget(self);
@@ -145,20 +166,20 @@ mod test {
         let a = box 8u as Box<Any>;
         let b = box Test as Box<Any>;
 
-        match a.downcast::<uint>() {
+        match a.move::<uint>() {
             Ok(a) => { assert!(a == box 8u); }
             Err(..) => fail!()
         }
-        match b.downcast::<Test>() {
+        match b.move::<Test>() {
             Ok(a) => { assert!(a == box Test); }
             Err(..) => fail!()
         }
 
         let a = box 8u as Box<Any>;
         let b = box Test as Box<Any>;
 
-        assert!(a.downcast::<Box<Test>>().is_err());
-        assert!(b.downcast::<Box<uint>>().is_err());
+        assert!(a.move::<Box<Test>>().is_err());
+        assert!(b.move::<Box<uint>>().is_err());
     }
 
     #[test]

branches/try2/src/libcollections/btree.rs

@@ -20,7 +20,7 @@
 
 use core::prelude::*;
 
-use alloc::boxed::Box;
+use alloc::owned::Box;
 use core::fmt;
 use core::fmt::Show;
 

branches/try2/src/libcollections/dlist.rs

@@ -23,7 +23,7 @@
 
 use core::prelude::*;
 
-use alloc::boxed::Box;
+use alloc::owned::Box;
 use core::default::Default;
 use core::fmt;
 use core::iter;

branches/try2/src/libcollections/hash/mod.rs

@@ -65,7 +65,7 @@
 
 use core::prelude::*;
 
-use alloc::boxed::Box;
+use alloc::owned::Box;
 use alloc::rc::Rc;
 use core::intrinsics::TypeId;
 use core::mem;

branches/try2/src/libcollections/treemap.rs

@@ -14,7 +14,7 @@
 
 use core::prelude::*;
 
-use alloc::boxed::Box;
+use alloc::owned::Box;
 use core::default::Default;
 use core::fmt;
 use core::fmt::Show;

branches/try2/src/libcollections/trie.rs

@@ -12,7 +12,7 @@
 
 use core::prelude::*;
 
-use alloc::boxed::Box;
+use alloc::owned::Box;
 use core::default::Default;
 use core::mem::zeroed;
 use core::mem;

branches/try2/src/libcore/cell.rs

@@ -163,13 +163,11 @@ use option::{None, Option, Some};
 use ty::Unsafe;
 
 /// A mutable memory location that admits only `Copy` data.
-#[unstable = "likely to be renamed; otherwise stable"]
 pub struct Cell<T> {
     value: Unsafe<T>,
     noshare: marker::NoShare,
 }
 
-#[stable]
 impl<T:Copy> Cell<T> {
     /// Creates a new `Cell` containing the given value.
     pub fn new(value: T) -> Cell<T> {
@@ -194,22 +192,20 @@ impl<T:Copy> Cell<T> {
     }
 }
 
-#[unstable = "waiting for `Clone` trait to become stable"]
+#[unstable]
 impl<T:Copy> Clone for Cell<T> {
     fn clone(&self) -> Cell<T> {
         Cell::new(self.get())
     }
 }
 
-#[unstable = "waiting for `PartialEq` trait to become stable"]
 impl<T:PartialEq + Copy> PartialEq for Cell<T> {
     fn eq(&self, other: &Cell<T>) -> bool {
         self.get() == other.get()
     }
 }
 
 /// A mutable memory location with dynamically checked borrow rules
-#[unstable = "likely to be renamed; otherwise stable"]
 pub struct RefCell<T> {
     value: Unsafe<T>,
     borrow: Cell<BorrowFlag>,
@@ -225,7 +221,6 @@ static WRITING: BorrowFlag = -1;
 
 impl<T> RefCell<T> {
     /// Create a new `RefCell` containing `value`
-    #[stable]
     pub fn new(value: T) -> RefCell<T> {
         RefCell {
             value: Unsafe::new(value),
@@ -236,7 +231,6 @@ impl<T> RefCell<T> {
     }
 
     /// Consumes the `RefCell`, returning the wrapped value.
-    #[unstable = "may be renamed, depending on global conventions"]
     pub fn unwrap(self) -> T {
         debug_assert!(self.borrow.get() == UNUSED);
         unsafe{self.value.unwrap()}
@@ -248,7 +242,6 @@ impl<T> RefCell<T> {
     /// immutable borrows can be taken out at the same time.
     ///
     /// Returns `None` if the value is currently mutably borrowed.
-    #[unstable = "may be renamed, depending on global conventions"]
     pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> {
         match self.borrow.get() {
             WRITING => None,
@@ -267,7 +260,6 @@ impl<T> RefCell<T> {
     /// # Failure
     ///
     /// Fails if the value is currently mutably borrowed.
-    #[unstable]
     pub fn borrow<'a>(&'a self) -> Ref<'a, T> {
         match self.try_borrow() {
             Some(ptr) => ptr,
@@ -281,7 +273,6 @@ impl<T> RefCell<T> {
     /// cannot be borrowed while this borrow is active.
     ///
     /// Returns `None` if the value is currently borrowed.
-    #[unstable = "may be renamed, depending on global conventions"]
     pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> {
         match self.borrow.get() {
             UNUSED => {
@@ -300,7 +291,6 @@ impl<T> RefCell<T> {
     /// # Failure
     ///
     /// Fails if the value is currently borrowed.
-    #[unstable]
     pub fn borrow_mut<'a>(&'a self) -> RefMut<'a, T> {
         match self.try_borrow_mut() {
             Some(ptr) => ptr,
@@ -309,30 +299,27 @@ impl<T> RefCell<T> {
     }
 }
 
-#[unstable = "waiting for `Clone` to become stable"]
+#[unstable]
 impl<T: Clone> Clone for RefCell<T> {
     fn clone(&self) -> RefCell<T> {
         RefCell::new(self.borrow().clone())
     }
 }
 
-#[unstable = "waiting for `PartialEq` to become stable"]
 impl<T: PartialEq> PartialEq for RefCell<T> {
     fn eq(&self, other: &RefCell<T>) -> bool {
         *self.borrow() == *other.borrow()
     }
 }
 
 /// Wraps a borrowed reference to a value in a `RefCell` box.
-#[unstable]
 pub struct Ref<'b, T> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
     _parent: &'b RefCell<T>
 }
 
 #[unsafe_destructor]
-#[unstable]
 impl<'b, T> Drop for Ref<'b, T> {
     fn drop(&mut self) {
         let borrow = self._parent.borrow.get();
@@ -341,7 +328,6 @@ impl<'b, T> Drop for Ref<'b, T> {
     }
 }
 
-#[unstable = "waiting for `Deref` to become stable"]
 impl<'b, T> Deref<T> for Ref<'b, T> {
     #[inline]
     fn deref<'a>(&'a self) -> &'a T {
@@ -355,7 +341,7 @@ impl<'b, T> Deref<T> for Ref<'b, T> {
 ///
 /// A `Clone` implementation would interfere with the widespread
 /// use of `r.borrow().clone()` to clone the contents of a `RefCell`.
-#[experimental = "likely to be moved to a method, pending language changes"]
+#[experimental]
 pub fn clone_ref<'b, T>(orig: &Ref<'b, T>) -> Ref<'b, T> {
     // Since this Ref exists, we know the borrow flag
     // is not set to WRITING.
@@ -369,15 +355,13 @@ pub fn clone_ref<'b, T>(orig: &Ref<'b, T>) -> Ref<'b, T> {
 }
 
 /// Wraps a mutable borrowed reference to a value in a `RefCell` box.
-#[unstable]
 pub struct RefMut<'b, T> {
     // FIXME #12808: strange name to try to avoid interfering with
     // field accesses of the contained type via Deref
     _parent: &'b RefCell<T>
 }
 
 #[unsafe_destructor]
-#[unstable]
 impl<'b, T> Drop for RefMut<'b, T> {
     fn drop(&mut self) {
         let borrow = self._parent.borrow.get();
@@ -386,15 +370,13 @@ impl<'b, T> Drop for RefMut<'b, T> {
     }
 }
 
-#[unstable = "waiting for `Deref` to become stable"]
 impl<'b, T> Deref<T> for RefMut<'b, T> {
     #[inline]
     fn deref<'a>(&'a self) -> &'a T {
         unsafe { &*self._parent.value.get() }
     }
 }
 
-#[unstable = "waiting for `DerefMut` to become stable"]
 impl<'b, T> DerefMut<T> for RefMut<'b, T> {
     #[inline]
     fn deref_mut<'a>(&'a mut self) -> &'a mut T {