---

yaml
---
r: 61398
b: refs/heads/try
c: cd2eb47
h: refs/heads/master
v: v3

Author: huonw

[refs]

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

branches/try/.swo

@@ -1562,7 +1562,7 @@ Supported traits for `deriving` are:
 
 * Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
 * Serialization: `Encodable`, `Decodable`. These require `std`.
-* `Clone`, to perform deep copies.
+* `Clone` and `DeepClone`, to perform (deep) copies.
 * `IterBytes`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
 * `ToStr`, to convert to a string. For a type with this instance,

branches/try/doc/rust.md

@@ -2308,8 +2308,8 @@ enum ABC { A, B, C }
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable` `Decodable`, `Clone`, `IterBytes`, `Rand` and
-`ToStr`.
+`TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`,
+`IterBytes`, `Rand` and `ToStr`.
 
 # Modules and crates
 

branches/try/doc/tutorial.md

@@ -22,8 +22,6 @@ by convention implementing the `Clone` trait and calling the
 
 */
 
-use core::kinds::Const;
-
 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.
@@ -48,12 +46,6 @@ 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 {
@@ -86,32 +78,11 @@ 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`.
+    /// 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;
 }
 
-impl<T: DeepClone> DeepClone for ~T {
-    /// Return a deep copy of the owned box.
-    #[inline(always)]
-    fn deep_clone(&self) -> ~T { ~(**self).deep_clone() }
-}
-
-// FIXME: #6525: should also be implemented for `T: Owned + DeepClone`
-impl<T: Const + DeepClone> DeepClone for @T {
-    /// Return a deep copy of the managed box. The `Const` trait is required to prevent performing
-    /// a deep clone of a potentially cyclical type.
-    #[inline(always)]
-    fn deep_clone(&self) -> @T { @(**self).deep_clone() }
-}
-
-// FIXME: #6525: should also be implemented for `T: Owned + DeepClone`
-impl<T: Const + DeepClone> DeepClone for @mut T {
-    /// Return a deep copy of the managed box. The `Const` trait is required to prevent performing
-    /// a deep clone of a potentially cyclical type.
-    #[inline(always)]
-    fn deep_clone(&self) -> @mut T { @mut (**self).deep_clone() }
-}
-
 macro_rules! deep_clone_impl(
     ($t:ty) => {
         impl DeepClone for $t {
@@ -122,6 +93,12 @@ macro_rules! deep_clone_impl(
     }
 )
 
+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)
@@ -144,39 +121,23 @@ deep_clone_impl!(char)
 
 #[test]
 fn test_owned_clone() {
-    let a = ~5i;
+    let a: ~int = ~5i;
     let b: ~int = a.clone();
     assert!(a == b);
 }
 
 #[test]
 fn test_managed_clone() {
-    let a = @5i;
+    let a: @int = @5i;
     let b: @int = a.clone();
     assert!(a == b);
 }
 
-#[test]
-fn test_managed_mut_deep_clone() {
-    let x = @mut 5i;
-    let y: @mut int = x.deep_clone();
-    *x = 20;
-    assert_eq!(*y, 5);
-}
-
 #[test]
 fn test_managed_mut_clone() {
-    let a = @mut 5i;
+    let a: @mut int = @mut 5i;
     let b: @mut int = a.clone();
     assert!(a == b);
     *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/clone.rs

@@ -289,33 +289,6 @@ pub fn setenv(n: &str, v: &str) {
     }
 }
 
-/// Remove a variable from the environment entirely
-pub fn unsetenv(n: &str) {
-    #[cfg(unix)]
-    fn _unsetenv(n: &str) {
-        unsafe {
-            do with_env_lock {
-                do str::as_c_str(n) |nbuf| {
-                    libc::funcs::posix01::unistd::unsetenv(nbuf);
-                }
-            }
-        }
-    }
-    #[cfg(windows)]
-    fn _unsetenv(n: &str) {
-        unsafe {
-            do with_env_lock {
-                use os::win32::as_utf16_p;
-                do as_utf16_p(n) |nbuf| {
-                    libc::SetEnvironmentVariableW(nbuf, ptr::null());
-                }
-            }
-        }
-    }
-
-    _unsetenv(n);
-}
-
 pub fn fdopen(fd: c_int) -> *FILE {
     unsafe {
         return do as_c_charp("r") |modebuf| {
@@ -1439,7 +1412,7 @@ mod tests {
     use option::Some;
     use option;
     use os::{as_c_charp, env, getcwd, getenv, make_absolute, real_args};
-    use os::{remove_file, setenv, unsetenv};
+    use os::{remove_file, setenv};
     use os;
     use path::Path;
     use rand::RngUtil;
@@ -1475,14 +1448,6 @@ mod tests {
         assert!(getenv(n) == option::Some(~"VALUE"));
     }
 
-    #[test]
-    fn test_unsetenv() {
-        let n = make_rand_name();
-        setenv(n, ~"VALUE");
-        unsetenv(n);
-        assert!(getenv(n) == option::None);
-    }
-
     #[test]
     #[ignore(cfg(windows))]
     #[ignore]

branches/try/src/libcore/os.rs

@@ -2546,29 +2546,23 @@ pub mod raw {
      * would also make any pointers to it invalid.
      */
     #[inline(always)]
-    pub fn to_ptr<T>(v: &[T]) -> *T {
-        unsafe {
-            let repr: **SliceRepr = transmute(&v);
-            transmute(&((**repr).data))
-        }
+    pub unsafe fn to_ptr<T>(v: &[T]) -> *T {
+        let repr: **SliceRepr = transmute(&v);
+        transmute(&((**repr).data))
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    pub fn to_const_ptr<T>(v: &const [T]) -> *const T {
-        unsafe {
-            let repr: **SliceRepr = transmute(&v);
-            transmute(&((**repr).data))
-        }
+    pub unsafe fn to_const_ptr<T>(v: &const [T]) -> *const T {
+        let repr: **SliceRepr = transmute(&v);
+        transmute(&((**repr).data))
     }
 
     /** see `to_ptr()` */
     #[inline(always)]
-    pub fn to_mut_ptr<T>(v: &mut [T]) -> *mut T {
-        unsafe {
-            let repr: **SliceRepr = transmute(&v);
-            transmute(&((**repr).data))
-        }
+    pub unsafe fn to_mut_ptr<T>(v: &mut [T]) -> *mut T {
+        let repr: **SliceRepr = transmute(&v);
+        transmute(&((**repr).data))
     }
 
     /**

branches/try/src/libcore/vec.rs

@@ -93,9 +93,7 @@ fn test_sysroot() -> Path {
     self_path.pop()
 }
 
-// Ignored on i686 -- see #6517
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_make_dir_rwx() {
     let temp = &os::tmpdir();
     let dir = temp.push(~"quux");
@@ -109,7 +107,6 @@ fn test_make_dir_rwx() {
 }
 
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_install_valid() {
     let sysroot = test_sysroot();
     debug!("sysroot = %s", sysroot.to_str());
@@ -135,7 +132,6 @@ fn test_install_valid() {
 }
 
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_install_invalid() {
     use conditions::nonexistent_package::cond;
     use cond1 = conditions::missing_pkg_files::cond;
@@ -158,7 +154,6 @@ fn test_install_invalid() {
 }
 
 #[test]
-#[ignore(cfg(target_arch = "x86"))]
 fn test_install_url() {
     let workspace = mkdtemp(&os::tmpdir(), "test").expect("couldn't create temp dir");
     let sysroot = test_sysroot();