---

yaml
---
r: 95354
b: refs/heads/dist-snap
c: f3b1f79
h: refs/heads/master
v: v3

Author: fhahn

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: c147ec6d06b19b6e84f488212d7775b5eb937754
+refs/heads/dist-snap: f3b1f79716394a91afa179ee27620679c4651228
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libextra/extra.rs

@@ -46,6 +46,7 @@ pub use std::os;
 
 pub mod c_vec;
 pub mod io_util;
+pub mod rc;
 
 // Concurrency
 

branches/dist-snap/src/libstd/rc.rs renamed to branches/dist-snap/src/libextra/rc.rs

@@ -8,23 +8,31 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/** Task-local reference counted boxes
+#[allow(missing_doc)];
 
-The `Rc` type provides shared ownership of an immutable value. Destruction is deterministic, and
-will occur as soon as the last owner is gone. It is marked as non-sendable because it avoids the
-overhead of atomic reference counting.
+/** Task-local reference counted smart pointers
 
-The `RcMut` type provides shared ownership of a mutable value. Since multiple owners prevent
-inherited mutability, a dynamic freezing check is used to maintain the invariant that an `&mut`
-reference is a unique handle and the type is marked as non-`Freeze`.
+Task-local reference counted smart pointers are an alternative to managed boxes with deterministic
+destruction. They are restricted to containing types that are either `Send` or `Freeze` (or both) to
+prevent cycles.
+
+Neither `Rc<T>` or `RcMut<T>` is ever `Send` and `RcMut<T>` is never `Freeze`. If `T` is `Freeze`, a
+cycle cannot be created with `Rc<T>` because there is no way to modify it after creation.
 
 */
 
-use ptr::RawPtr;
-use unstable::intrinsics::transmute;
-use ops::Drop;
-use kinds::{Freeze, Send};
-use clone::{Clone, DeepClone};
+
+use std::cast;
+use std::ptr;
+use std::unstable::intrinsics;
+
+// Convert ~T into *mut T without dropping it
+#[inline]
+unsafe fn owned_to_raw<T>(mut box: ~T) -> *mut T {
+    let ptr = ptr::to_mut_unsafe_ptr(box);
+    intrinsics::forget(box);
+    ptr
+}
 
 struct RcBox<T> {
     value: T,
@@ -35,38 +43,50 @@ struct RcBox<T> {
 #[unsafe_no_drop_flag]
 #[no_send]
 pub struct Rc<T> {
-    priv ptr: *mut RcBox<T>
+    priv ptr: *mut RcBox<T>,
+}
+
+impl<T> Rc<T> {
+    unsafe fn new(value: T) -> Rc<T> {
+        Rc{ptr: owned_to_raw(~RcBox{value: value, count: 1})}
+    }
+}
+
+impl<T: Send> Rc<T> {
+    pub fn from_send(value: T) -> Rc<T> {
+        unsafe { Rc::new(value) }
+    }
 }
 
 impl<T: Freeze> Rc<T> {
-    /// Construct a new reference-counted box from a `Freeze` value
-    #[inline]
-    pub fn new(value: T) -> Rc<T> {
-        unsafe {
-            Rc::new_unchecked(value)
-        }
+    pub fn from_freeze(value: T) -> Rc<T> {
+        unsafe { Rc::new(value) }
     }
 }
 
 impl<T> Rc<T> {
-    /// Unsafety construct a new reference-counted box from any value.
-    ///
-    /// If the type is not `Freeze`, the `Rc` box will incorrectly still be considered as a `Freeze`
-    /// type. It is also possible to create cycles, which will leak, and may interact poorly with
-    /// managed pointers.
     #[inline]
-    pub unsafe fn new_unchecked(value: T) -> Rc<T> {
-        Rc{ptr: transmute(~RcBox{value: value, count: 1})}
+    pub fn borrow<'r>(&'r self) -> &'r T {
+        unsafe { cast::copy_lifetime(self, &(*self.ptr).value) }
     }
+}
 
-    /// Borrow the value contained in the reference-counted box
-    #[inline]
-    pub fn borrow<'r>(&'r self) -> &'r T {
-        unsafe { &(*self.ptr).value }
+#[unsafe_destructor]
+impl<T> Drop for Rc<T> {
+    fn drop(&mut self) {
+        unsafe {
+            if self.ptr.is_not_null() {
+                (*self.ptr).count -= 1;
+                if (*self.ptr).count == 0 {
+                    let _: ~T = cast::transmute(self.ptr);
+                }
+            }
+        }
     }
 }
 
 impl<T> Clone for Rc<T> {
+    /// Return a shallow copy of the reference counted pointer.
     #[inline]
     fn clone(&self) -> Rc<T> {
         unsafe {
@@ -77,75 +97,56 @@ impl<T> Clone for Rc<T> {
 }
 
 impl<T: DeepClone> DeepClone for Rc<T> {
+    /// Return a deep copy of the reference counted pointer.
     #[inline]
     fn deep_clone(&self) -> Rc<T> {
-        unsafe { Rc::new_unchecked(self.borrow().deep_clone()) }
-    }
-}
-
-#[unsafe_destructor]
-impl<T> Drop for Rc<T> {
-    fn drop(&mut self) {
-        unsafe {
-            if self.ptr.is_not_null() {
-                (*self.ptr).count -= 1;
-                if (*self.ptr).count == 0 {
-                    let _: ~RcBox<T> = transmute(self.ptr);
-                }
-            }
-        }
+        unsafe { Rc::new(self.borrow().deep_clone()) }
     }
 }
 
 #[cfg(test)]
 mod test_rc {
     use super::*;
-    use cell::Cell;
+    use std::cell::Cell;
 
     #[test]
     fn test_clone() {
-        unsafe {
-            let x = Rc::new_unchecked(Cell::new(5));
-            let y = x.clone();
-            do x.borrow().with_mut_ref |inner| {
-                *inner = 20;
-            }
-            assert_eq!(y.borrow().take(), 20);
+        let x = Rc::from_send(Cell::new(5));
+        let y = x.clone();
+        do x.borrow().with_mut_ref |inner| {
+            *inner = 20;
         }
+        assert_eq!(y.borrow().take(), 20);
     }
 
     #[test]
     fn test_deep_clone() {
-        unsafe {
-            let x = Rc::new_unchecked(Cell::new(5));
-            let y = x.deep_clone();
-            do x.borrow().with_mut_ref |inner| {
-                *inner = 20;
-            }
-            assert_eq!(y.borrow().take(), 5);
+        let x = Rc::from_send(Cell::new(5));
+        let y = x.deep_clone();
+        do x.borrow().with_mut_ref |inner| {
+            *inner = 20;
         }
+        assert_eq!(y.borrow().take(), 5);
     }
 
     #[test]
     fn test_simple() {
-        let x = Rc::new(5);
+        let x = Rc::from_freeze(5);
         assert_eq!(*x.borrow(), 5);
     }
 
     #[test]
     fn test_simple_clone() {
-        let x = Rc::new(5);
+        let x = Rc::from_freeze(5);
         let y = x.clone();
         assert_eq!(*x.borrow(), 5);
         assert_eq!(*y.borrow(), 5);
     }
 
     #[test]
     fn test_destructor() {
-        unsafe {
-            let x = Rc::new_unchecked(~5);
-            assert_eq!(**x.borrow(), 5);
-        }
+        let x = Rc::from_send(~5);
+        assert_eq!(**x.borrow(), 5);
     }
 }
 
@@ -170,30 +171,21 @@ pub struct RcMut<T> {
     priv ptr: *mut RcMutBox<T>,
 }
 
-impl<T: Freeze> RcMut<T> {
-    /// Construct a new mutable reference-counted box from a `Freeze` value
-    #[inline]
-    pub fn new(value: T) -> RcMut<T> {
-        unsafe { RcMut::new_unchecked(value) }
+impl<T> RcMut<T> {
+    unsafe fn new(value: T) -> RcMut<T> {
+        RcMut{ptr: owned_to_raw(~RcMutBox{value: value, count: 1, borrow: Nothing})}
     }
 }
 
 impl<T: Send> RcMut<T> {
-    /// Construct a new mutable reference-counted box from a `Send` value
-    #[inline]
     pub fn from_send(value: T) -> RcMut<T> {
-        unsafe { RcMut::new_unchecked(value) }
+        unsafe { RcMut::new(value) }
     }
 }
 
-impl<T> RcMut<T> {
-    /// Unsafety construct a new mutable reference-counted box from any value.
-    ///
-    /// It is possible to create cycles, which will leak, and may interact
-    /// poorly with managed pointers.
-    #[inline]
-    pub unsafe fn new_unchecked(value: T) -> RcMut<T> {
-        RcMut{ptr: transmute(~RcMutBox{value: value, count: 1, borrow: Nothing})}
+impl<T: Freeze> RcMut<T> {
+    pub fn from_freeze(value: T) -> RcMut<T> {
+        unsafe { RcMut::new(value) }
     }
 }
 
@@ -231,7 +223,7 @@ impl<T> Drop for RcMut<T> {
             if self.ptr.is_not_null() {
                 (*self.ptr).count -= 1;
                 if (*self.ptr).count == 0 {
-                    let _: ~RcMutBox<T> = transmute(self.ptr);
+                    let _: ~T = cast::transmute(self.ptr);
                 }
             }
         }
@@ -255,7 +247,7 @@ impl<T: DeepClone> DeepClone for RcMut<T> {
     fn deep_clone(&self) -> RcMut<T> {
         do self.with_borrow |x| {
             // FIXME: #6497: should avoid freeze (slow)
-            unsafe { RcMut::new_unchecked(x.deep_clone()) }
+            unsafe { RcMut::new(x.deep_clone()) }
         }
     }
 }
@@ -278,7 +270,7 @@ mod test_rc_mut {
 
     #[test]
     fn test_deep_clone() {
-        let x = RcMut::new(5);
+        let x = RcMut::from_freeze(5);
         let y = x.deep_clone();
         do x.with_mut_borrow |value| {
             *value = 20;
@@ -306,7 +298,7 @@ mod test_rc_mut {
 
     #[test]
     fn modify() {
-        let x = RcMut::new(5);
+        let x = RcMut::from_freeze(5);
         let y = x.clone();
 
         do y.with_mut_borrow |a| {
@@ -328,7 +320,7 @@ mod test_rc_mut {
 
     #[test]
     fn release_mutable() {
-        let x = RcMut::new(5);
+        let x = RcMut::from_freeze(5);
         do x.with_mut_borrow |_| {}
         do x.with_borrow |_| {}
     }
@@ -348,7 +340,7 @@ mod test_rc_mut {
     #[test]
     #[should_fail]
     fn mutable_dupe() {
-        let x = RcMut::new(5);
+        let x = RcMut::from_freeze(5);
         let y = x.clone();
 
         do x.with_mut_borrow |_| {
@@ -372,7 +364,7 @@ mod test_rc_mut {
     #[test]
     #[should_fail]
     fn restore_freeze() {
-        let x = RcMut::new(5);
+        let x = RcMut::from_freeze(5);
         let y = x.clone();
 
         do x.with_borrow |_| {

branches/dist-snap/src/libextra/tempfile.rs

@@ -15,63 +15,17 @@ use std::os;
 use std::rand::Rng;
 use std::rand;
 
-/// A wrapper for a path to temporary directory implementing automatic
-/// scope-pased deletion.
-pub struct TempDir {
-    priv path: Option<Path>
-}
-
-impl TempDir {
-    /// Attempts to make a temporary directory inside of `tmpdir` whose name
-    /// will have the suffix `suffix`. The directory will be automatically
-    /// deleted once the returned wrapper is destroyed.
-    ///
-    /// If no directory can be created, None is returned.
-    pub fn new_in(tmpdir: &Path, suffix: &str) -> Option<TempDir> {
-        if !tmpdir.is_absolute() {
-            let abs_tmpdir = os::make_absolute(tmpdir);
-            return TempDir::new_in(&abs_tmpdir, suffix);
-        }
-
-        let mut r = rand::rng();
-        for _ in range(0u, 1000) {
-            let p = tmpdir.push(r.gen_ascii_str(16) + suffix);
-            if os::make_dir(&p, 0x1c0) { // 700
-                return Some(TempDir { path: Some(p) });
-            }
-        }
-        None
-    }
-
-    /// Attempts to make a temporary directory inside of `os::tmpdir()` whose
-    /// name will have the suffix `suffix`. The directory will be automatically
-    /// deleted once the returned wrapper is destroyed.
-    ///
-    /// If no directory can be created, None is returned.
-    pub fn new(suffix: &str) -> Option<TempDir> {
-        TempDir::new_in(&os::tmpdir(), suffix)
-    }
-
-    /// Unwrap the wrapped `std::path::Path` from the `TempDir` wrapper.
-    /// This discards the wrapper so that the automatic deletion of the
-    /// temporary directory is prevented.
-    pub fn unwrap(self) -> Path {
-        let mut tmpdir = self;
-        tmpdir.path.take_unwrap()
-    }
-
-    /// Access the wrapped `std::path::Path` to the temporary directory.
-    pub fn path<'a>(&'a self) -> &'a Path {
-        self.path.get_ref()
-    }
-}
-
-impl Drop for TempDir {
-    fn drop(&mut self) {
-        for path in self.path.iter() {
-            os::remove_dir_recursive(path);
+/// Attempts to make a temporary directory inside of `tmpdir` whose name will
+/// have the suffix `suffix`. If no directory can be created, None is returned.
+pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
+    let mut r = rand::rng();
+    for _ in range(0u, 1000) {
+        let p = tmpdir.push(r.gen_ascii_str(16) + suffix);
+        if os::make_dir(&p, 0x1c0) { // 700
+            return Some(p);
         }
     }
+    None
 }
 
 // the tests for this module need to change the path using change_dir,