---

yaml
---
r: 61374
b: refs/heads/try
c: 22c3db5
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: 8a15333c06b8ba491e1654c3fca3fa21d21def9b
+refs/heads/try: 22c3db5df786316c7a7c702aad93e9f0e9a4061d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/etc/vim/after/syntax/rust.vim

@@ -11,6 +11,10 @@ syn match rustRightArrowHead contained ">" conceal cchar= 
 syn match rustRightArrowTail contained "-" conceal cchar=⟶
 syn match rustNiceOperator "->" contains=rustRightArrowHead,rustRightArrowTail
 
+syn match rustLeftRightArrowHead contained ">" conceal cchar= 
+syn match rustLeftRightArrowTail contained "<-" conceal cchar=⟷
+syn match rustNiceOperator "<->" contains=rustLeftRightArrowHead,rustLeftRightArrowTail
+
 syn match rustFatRightArrowHead contained ">" conceal cchar= 
 syn match rustFatRightArrowTail contained "=" conceal cchar=⟹
 syn match rustNiceOperator "=>" contains=rustFatRightArrowHead,rustFatRightArrowTail

branches/try/src/etc/vim/syntax/rust.vim

@@ -15,7 +15,7 @@ syn keyword   rustOperator    as
 
 syn keyword   rustKeyword     break copy do drop extern
 syn keyword   rustKeyword     for if impl let log
-syn keyword   rustKeyword     copy do extern
+syn keyword   rustKeyword     copy do drop extern
 syn keyword   rustKeyword     for impl let log
 syn keyword   rustKeyword     loop mod once priv pub
 syn keyword   rustKeyword     return
@@ -28,8 +28,8 @@ syn keyword   rustStorage     const mut ref static
 syn match     rustIdentifier  contains=rustIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 syn match     rustFuncName    "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 
-" reserved
-syn keyword   rustKeyword     be
+" Reserved words
+"syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128 be " These are obsolete
 
 syn keyword   rustType        int uint float char bool u8 u16 u32 u64 f32
 syn keyword   rustType        f64 i8 i16 i32 i64 str Self

branches/try/src/libcore/cell.rs

@@ -21,17 +21,10 @@ Similar to a mutable option type, but friendlier.
 */
 
 #[mutable]
-#[deriving(Clone)]
 pub struct Cell<T> {
     priv value: Option<T>
 }
 
-impl<T: DeepClone> DeepClone for Cell<T> {
-    fn deep_clone(&self) -> Cell<T> {
-        Cell{value: self.value.deep_clone()}
-    }
-}
-
 impl<T:cmp::Eq> cmp::Eq for Cell<T> {
     fn eq(&self, other: &Cell<T>) -> bool {
         (self.value) == (other.value)

branches/try/src/libcore/clone.rs

@@ -23,12 +23,17 @@ by convention implementing the `Clone` trait and calling the
 */
 
 pub trait Clone {
-    /// Return a deep copy of the owned object tree. Types with shared ownership like managed boxes
-    /// are cloned with a shallow copy.
+    /// Return a deep copy of the owned object tree. Managed boxes are cloned with a shallow copy.
     fn clone(&self) -> Self;
 }
 
-impl<T: Clone> Clone for ~T {
+impl Clone for () {
+    /// Return a copy of the value.
+    #[inline(always)]
+    fn clone(&self) -> () { () }
+}
+
+impl<T:Clone> Clone for ~T {
     /// Return a deep copy of the owned box.
     #[inline(always)]
     fn clone(&self) -> ~T { ~(**self).clone() }
@@ -46,10 +51,16 @@ impl<T> Clone for @mut T {
     fn clone(&self) -> @mut T { *self }
 }
 
+impl<'self, T> Clone for &'self T {
+    /// Return a shallow copy of the borrowed pointer.
+    #[inline(always)]
+    fn clone(&self) -> &'self T { *self }
+}
+
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {
-            /// Return a deep copy of the value.
+            /// Return a copy of the value.
             #[inline(always)]
             fn clone(&self) -> $t { *self }
         }
@@ -72,53 +83,9 @@ clone_impl!(float)
 clone_impl!(f32)
 clone_impl!(f64)
 
-clone_impl!(())
 clone_impl!(bool)
 clone_impl!(char)
 
-pub trait DeepClone {
-    /// Return a deep copy of the object tree. Types with shared ownership are also copied via a
-    /// deep copy, unlike `Clone`. Note that this is currently unimplemented for managed boxes, as
-    /// it would need to handle cycles.
-    fn deep_clone(&self) -> Self;
-}
-
-macro_rules! deep_clone_impl(
-    ($t:ty) => {
-        impl DeepClone for $t {
-            /// Return a deep copy of the value.
-            #[inline(always)]
-            fn deep_clone(&self) -> $t { *self }
-        }
-    }
-)
-
-impl<T: DeepClone> DeepClone for ~T {
-    /// Return a deep copy of the owned box.
-    #[inline(always)]
-    fn deep_clone(&self) -> ~T { ~(**self).deep_clone() }
-}
-
-deep_clone_impl!(int)
-deep_clone_impl!(i8)
-deep_clone_impl!(i16)
-deep_clone_impl!(i32)
-deep_clone_impl!(i64)
-
-deep_clone_impl!(uint)
-deep_clone_impl!(u8)
-deep_clone_impl!(u16)
-deep_clone_impl!(u32)
-deep_clone_impl!(u64)
-
-deep_clone_impl!(float)
-deep_clone_impl!(f32)
-deep_clone_impl!(f64)
-
-deep_clone_impl!(())
-deep_clone_impl!(bool)
-deep_clone_impl!(char)
-
 #[test]
 fn test_owned_clone() {
     let a: ~int = ~5i;
@@ -141,3 +108,11 @@ fn test_managed_mut_clone() {
     *b = 10;
     assert!(a == b);
 }
+
+#[test]
+fn test_borrowed_clone() {
+    let x = 5i;
+    let y: &int = &x;
+    let z: &int = (&y).clone();
+    assert_eq!(*z, 5);
+}

branches/try/src/libcore/option.rs

@@ -49,7 +49,6 @@ use num::Zero;
 use old_iter::{BaseIter, MutableIter, ExtendedIter};
 use old_iter;
 use str::StrSlice;
-use clone::DeepClone;
 
 #[cfg(test)] use str;
 
@@ -60,15 +59,6 @@ pub enum Option<T> {
     Some(T),
 }
 
-impl<T: DeepClone> DeepClone for Option<T> {
-    fn deep_clone(&self) -> Option<T> {
-        match *self {
-            Some(ref x) => Some(x.deep_clone()),
-            None => None
-        }
-    }
-}
-
 impl<T:Ord> Ord for Option<T> {
     fn lt(&self, other: &Option<T>) -> bool {
         match (self, other) {

branches/try/src/libcore/prelude.rs

@@ -27,7 +27,7 @@ pub use io::{print, println};
 
 /* Reexported types and traits */
 
-pub use clone::{Clone, DeepClone};
+pub use clone::Clone;
 pub use cmp::{Eq, ApproxEq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;

branches/try/src/libcore/task/local_data_priv.rs

@@ -94,10 +94,12 @@ unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
     let map_ptr = rt::rust_get_task_local_data(task);
     if map_ptr.is_null() {
         let map: TaskLocalMap = @mut ~[];
-        // NB: This bumps the ref count before converting to an unsafe pointer,
-        // keeping the map alive until TLS is destroyed
         rt::rust_set_task_local_data(task, cast::transmute(map));
         rt::rust_task_local_data_atexit(task, cleanup_task_local_map_extern_cb);
+        // Also need to reference it an extra time to keep it for now.
+        let nonmut = cast::transmute::<TaskLocalMap,
+                                       @~[Option<TaskLocalElement>]>(map);
+        cast::bump_box_refcount(nonmut);
         map
     } else {
         let map = cast::transmute(map_ptr);

branches/try/src/librusti/rusti.rc

@@ -446,7 +446,7 @@ mod tests {
         }
     }
 
-    #[test] #[ignore]
+    #[test]
     fn run_all() {
         // By default, unit tests are run in parallel. Rusti, on the other hand,
         // does not enjoy doing this. I suspect that it is because the LLVM

branches/try/src/libstd/rc.rs

@@ -76,7 +76,6 @@ impl<T: Owned> Drop for Rc<T> {
 
 
 impl<T: Owned> Clone for Rc<T> {
-    /// Return a shallow copy of the reference counted pointer.
     #[inline]
     fn clone(&self) -> Rc<T> {
         unsafe {
@@ -86,38 +85,9 @@ impl<T: Owned> Clone for Rc<T> {
     }
 }
 
-impl<T: Owned + DeepClone> DeepClone for Rc<T> {
-    /// Return a deep copy of the reference counted pointer.
-    #[inline]
-    fn deep_clone(&self) -> Rc<T> {
-        Rc::new(self.borrow().deep_clone())
-    }
-}
-
 #[cfg(test)]
 mod test_rc {
     use super::*;
-    use core::cell::Cell;
-
-    #[test]
-    fn test_clone() {
-        let x = Rc::new(Cell(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() {
-        let x = Rc::new(Cell(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() {
@@ -126,7 +96,7 @@ mod test_rc {
     }
 
     #[test]
-    fn test_simple_clone() {
+    fn test_clone() {
         let x = Rc::new(5);
         let y = x.clone();
         assert_eq!(*x.borrow(), 5);
@@ -179,26 +149,24 @@ pub impl<T: Owned> RcMut<T> {
 
     /// Fails if there is already a mutable borrow of the box
     #[inline]
-    fn with_borrow<U>(&self, f: &fn(&T) -> U) -> U {
+    fn with_borrow(&self, f: &fn(&T)) {
         unsafe {
             assert!((*self.ptr).borrow != Mutable);
             let previous = (*self.ptr).borrow;
             (*self.ptr).borrow = Immutable;
-            let res = f(&(*self.ptr).value);
+            f(&(*self.ptr).value);
             (*self.ptr).borrow = previous;
-            res
         }
     }
 
     /// Fails if there is already a mutable or immutable borrow of the box
     #[inline]
-    fn with_mut_borrow<U>(&self, f: &fn(&mut T) -> U) -> U {
+    fn with_mut_borrow(&self, f: &fn(&mut T)) {
         unsafe {
             assert!((*self.ptr).borrow == Nothing);
             (*self.ptr).borrow = Mutable;
-            let res = f(&mut (*self.ptr).value);
+            f(&mut (*self.ptr).value);
             (*self.ptr).borrow = Nothing;
-            res
         }
     }
 }
@@ -232,7 +200,6 @@ impl<T: Owned> Drop for RcMut<T> {
 }
 
 impl<T: Owned> Clone for RcMut<T> {
-    /// Return a shallow copy of the reference counted pointer.
     #[inline]
     fn clone(&self) -> RcMut<T> {
         unsafe {
@@ -242,45 +209,10 @@ impl<T: Owned> Clone for RcMut<T> {
     }
 }
 
-impl<T: Owned + DeepClone> DeepClone for RcMut<T> {
-    /// Return a deep copy of the reference counted pointer.
-    #[inline]
-    fn deep_clone(&self) -> RcMut<T> {
-        do self.with_borrow |x| {
-            // FIXME: #6497: should avoid freeze (slow)
-            RcMut::new(x.deep_clone())
-        }
-    }
-}
-
 #[cfg(test)]
 mod test_rc_mut {
     use super::*;
 
-    #[test]
-    fn test_clone() {
-        let x = RcMut::new(5);
-        let y = x.clone();
-        do x.with_mut_borrow |value| {
-            *value = 20;
-        }
-        do y.with_borrow |value| {
-            assert_eq!(*value, 20);
-        }
-    }
-
-    #[test]
-    fn test_deep_clone() {
-        let x = RcMut::new(5);
-        let y = x.deep_clone();
-        do x.with_mut_borrow |value| {
-            *value = 20;
-        }
-        do y.with_borrow |value| {
-            assert_eq!(*value, 5);
-        }
-    }
-
     #[test]
     fn borrow_many() {
         let x = RcMut::new(5);