Removed DeepClone. Issue #12698.

13 files changed, 20 insertions, 209 deletions

diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs
index f4b530644a7..398091b60ca 100644
--- a/src/libstd/cell.rs
+++ b/src/libstd/cell.rs
@@ -11,7 +11,7 @@
 //! Types dealing with dynamic mutability
 
 use cast;
-use clone::{Clone, DeepClone};
+use clone::Clone;
 use cmp::Eq;
 use fmt;
 use kinds::{marker, Pod};
@@ -222,13 +222,6 @@ impl<T: Clone> Clone for RefCell<T> {
     }
 }
 
-impl<T: DeepClone> DeepClone for RefCell<T> {
-    fn deep_clone(&self) -> RefCell<T> {
-        let x = self.borrow();
-        RefCell::new(x.get().deep_clone())
-    }
-}
-
 impl<T: Eq> Eq for RefCell<T> {
     fn eq(&self, other: &RefCell<T>) -> bool {
         let a = self.borrow();
diff --git a/src/libstd/clone.rs b/src/libstd/clone.rs
index e5e79b4386a..ce5f056622f 100644
--- a/src/libstd/clone.rs
+++ b/src/libstd/clone.rs
@@ -21,8 +21,6 @@ the `clone` method.
 
 */
 
-use std::kinds::Freeze;
-
 /// A common trait for cloning an object.
 pub trait Clone {
     /// Returns a copy of the value. The contents of owned pointers
@@ -125,92 +123,6 @@ extern_fn_clone!(A, B, C, D, E, F)
 extern_fn_clone!(A, B, C, D, E, F, G)
 extern_fn_clone!(A, B, C, D, E, F, G, H)
 
-/// A trait distinct from `Clone` which represents "deep copies" of things like
-/// managed boxes which would otherwise not be copied.
-pub trait DeepClone: Clone {
-    /// Return a deep copy of the value. Unlike `Clone`, the contents of shared pointer types
-    /// *are* copied.
-    fn deep_clone(&self) -> Self;
-
-    /// Perform deep copy-assignment from `source`.
-    ///
-    /// `a.deep_clone_from(&b)` is equivalent to `a = b.deep_clone()` in
-    /// functionality, but can be overridden to reuse the resources of `a` to
-    /// avoid unnecessary allocations.
-    #[inline(always)]
-    fn deep_clone_from(&mut self, source: &Self) {
-        *self = source.deep_clone()
-    }
-}
-
-impl<T: DeepClone> DeepClone for ~T {
-    /// Return a deep copy of the owned box.
-    #[inline]
-    fn deep_clone(&self) -> ~T { ~(**self).deep_clone() }
-
-    /// Perform deep copy-assignment from `source` by reusing the existing allocation.
-    fn deep_clone_from(&mut self, source: &~T) {
-        **self = (**source).deep_clone()
-    }
-}
-
-// FIXME: #6525: should also be implemented for `T: Send + DeepClone`
-impl<T: Freeze + DeepClone + 'static> DeepClone for @T {
-    /// Return a deep copy of the managed box. The `Freeze` trait is required to prevent performing
-    /// a deep clone of a potentially cyclical type.
-    #[inline]
-    fn deep_clone(&self) -> @T { @(**self).deep_clone() }
-}
-
-macro_rules! deep_clone_impl(
-    ($t:ty) => {
-        impl DeepClone for $t {
-            /// Return a deep copy of the value.
-            #[inline]
-            fn deep_clone(&self) -> $t { *self }
-        }
-    }
-)
-
-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!(f32)
-deep_clone_impl!(f64)
-
-deep_clone_impl!(())
-deep_clone_impl!(bool)
-deep_clone_impl!(char)
-
-macro_rules! extern_fn_deep_clone(
-    ($($A:ident),*) => (
-        impl<$($A,)* ReturnType> DeepClone for extern "Rust" fn($($A),*) -> ReturnType {
-            /// Return a copy of a function pointer
-            #[inline]
-            fn deep_clone(&self) -> extern "Rust" fn($($A),*) -> ReturnType { *self }
-        }
-    )
-)
-
-extern_fn_deep_clone!()
-extern_fn_deep_clone!(A)
-extern_fn_deep_clone!(A, B)
-extern_fn_deep_clone!(A, B, C)
-extern_fn_deep_clone!(A, B, C, D)
-extern_fn_deep_clone!(A, B, C, D, E)
-extern_fn_deep_clone!(A, B, C, D, E, F)
-extern_fn_deep_clone!(A, B, C, D, E, F, G)
-extern_fn_deep_clone!(A, B, C, D, E, F, G, H)
-
 #[test]
 fn test_owned_clone() {
     let a = ~5i;
@@ -242,14 +154,6 @@ fn test_clone_from() {
 }
 
 #[test]
-fn test_deep_clone_from() {
-    let a = ~5;
-    let mut b = ~10;
-    b.deep_clone_from(&a);
-    assert_eq!(*b, 5);
-}
-
-#[test]
 fn test_extern_fn_clone() {
     trait Empty {}
     impl Empty for int {}
@@ -261,8 +165,4 @@ fn test_extern_fn_clone() {
     let _ = test_fn_a.clone();
     let _ = test_fn_b::<int>.clone();
     let _ = test_fn_c.clone();
-
-    let _ = test_fn_a.deep_clone();
-    let _ = test_fn_b::<int>.deep_clone();
-    let _ = test_fn_c.deep_clone();
 }
diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs
index fa7c94ac994..907a2d21b69 100644
--- a/src/libstd/gc.rs
+++ b/src/libstd/gc.rs
@@ -19,8 +19,7 @@ collector is task-local so `Gc<T>` is not sendable.
 #[allow(experimental)];
 
 use kinds::marker;
-use kinds::Send;
-use clone::{Clone, DeepClone};
+use clone::Clone;
 use managed;
 
 /// Immutable garbage-collected pointer type
@@ -78,16 +77,6 @@ pub static GC: () = ();
 #[cfg(test)]
 pub static GC: () = ();
 
-/// The `Send` bound restricts this to acyclic graphs where it is well-defined.
-///
-/// A `Freeze` bound would also work, but `Send` *or* `Freeze` cannot be expressed.
-impl<T: DeepClone + Send + 'static> DeepClone for Gc<T> {
-    #[inline]
-    fn deep_clone(&self) -> Gc<T> {
-        Gc::new(self.borrow().deep_clone())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use prelude::*;
@@ -105,16 +94,6 @@ mod tests {
     }
 
     #[test]
-    fn test_deep_clone() {
-        let x = Gc::new(RefCell::new(5));
-        let y = x.deep_clone();
-        x.borrow().with_mut(|inner| {
-            *inner = 20;
-        });
-        assert_eq!(y.borrow().with(|x| *x), 5);
-    }
-
-    #[test]
     fn test_simple() {
         let x = Gc::new(5);
         assert_eq!(*x.borrow(), 5);
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 6bf3cdf52ab..11d7bc6c1bf 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -1757,7 +1757,7 @@ impl<'a,
 
 /// An iterator that yields `None` forever after the underlying iterator
 /// yields `None` once.
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct Fuse<T> {
     priv iter: T,
     priv done: bool
@@ -1946,7 +1946,7 @@ impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
 }
 
 /// An iterator over the range [start, stop)
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct Range<A> {
     priv state: A,
     priv stop: A,
@@ -2020,7 +2020,7 @@ impl<A: Int + Ord + Clone + ToPrimitive> DoubleEndedIterator<A> for Range<A> {
 }
 
 /// An iterator over the range [start, stop]
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct RangeInclusive<A> {
     priv range: Range<A>,
     priv done: bool
@@ -2083,7 +2083,7 @@ impl<A: Sub<A, A> + Int + Ord + Clone + ToPrimitive> DoubleEndedIterator<A>
 }
 
 /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct RangeStep<A> {
     priv state: A,
     priv stop: A,
@@ -2115,7 +2115,7 @@ impl<A: CheckedAdd + Ord + Clone> Iterator<A> for RangeStep<A> {
 }
 
 /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct RangeStepInclusive<A> {
     priv state: A,
     priv stop: A,
@@ -2150,7 +2150,7 @@ impl<A: CheckedAdd + Ord + Clone + Eq> Iterator<A> for RangeStepInclusive<A> {
 }
 
 /// An iterator that repeats an element endlessly
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct Repeat<A> {
     priv element: A
 }
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 2f377a52ef8..f53c95de414 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -15,7 +15,7 @@
 
 #[allow(missing_doc)];
 
-use clone::{Clone, DeepClone};
+use clone::Clone;
 use cmp::{Eq, Ord};
 use kinds::Pod;
 use mem::size_of;
@@ -247,7 +247,6 @@ pub trait Bitwise: Bounded
 /// may be useful for systems programming.
 pub trait Primitive: Pod
                    + Clone
-                   + DeepClone
                    + Num
                    + NumCast
                    + Ord
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 7997c5747b4..86f8c143a9e 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -39,8 +39,7 @@
 
 use any::Any;
 use clone::Clone;
-use clone::DeepClone;
-use cmp::{Eq, TotalOrd};
+use cmp::{Eq, TotalEq, TotalOrd};
 use default::Default;
 use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize};
 use kinds::Send;
@@ -48,7 +47,7 @@ use mem;
 use vec;
 
 /// The option type
-#[deriving(Clone, DeepClone, Eq, Ord, TotalEq, TotalOrd, Show)]
+#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Show)]
 pub enum Option<T> {
     /// No value
     None,
@@ -387,7 +386,7 @@ impl<T> Default for Option<T> {
 /////////////////////////////////////////////////////////////////////////////
 
 /// An iterator that yields either one or zero elements
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct Item<A> {
     priv opt: Option<A>
 }
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 321186e4808..a3380b5db1d 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -38,7 +38,7 @@ pub type RevStrComponents<'a> = Map<'a, &'a [u8], Option<&'a str>,
                                           RevComponents<'a>>;
 
 /// Represents a POSIX file path
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct Path {
     priv repr: ~[u8], // assumed to never be empty or contain NULs
     priv sepidx: Option<uint> // index of the final separator in repr
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 90f7890f9ea..5b358819e41 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -79,7 +79,7 @@ pub type RevComponents<'a> = Map<'a, Option<&'a str>, &'a [u8],
 //
 // The only error condition imposed here is valid utf-8. All other invalid paths are simply
 // preserved by the data structure; let the Windows API error out on them.
-#[deriving(Clone, DeepClone)]
+#[deriving(Clone)]
 pub struct Path {
     priv repr: ~str, // assumed to never be empty
     priv prefix: Option<PathPrefix>,
@@ -942,7 +942,7 @@ pub fn is_sep_byte_verbatim(u: &u8) -> bool {
 }
 
 /// Prefix types for Path
-#[deriving(Eq, Clone, DeepClone)]
+#[deriving(Eq, Clone)]
 pub enum PathPrefix {
     /// Prefix `\\?\`, uint is the length of the following component
     VerbatimPrefix(uint),
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index c1cd3a6d79f..b30c78e7962 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -38,7 +38,7 @@ pub use mem::drop;
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr, IntoBytes};
 pub use c_str::ToCStr;
 pub use char::Char;
-pub use clone::{Clone, DeepClone};
+pub use clone::Clone;
 pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv};
 pub use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 pub use iter::{FromIterator, Extendable};
diff --git a/src/libstd/rc.rs b/src/libstd/rc.rs
index 5daf6e797be..8a7edc728c0 100644
--- a/src/libstd/rc.rs
+++ b/src/libstd/rc.rs
@@ -24,7 +24,7 @@ pointers, and then storing the parent pointers as `Weak` pointers.
 */
 
 use cast::transmute;
-use clone::{Clone, DeepClone};
+use clone::Clone;
 use cmp::{Eq, Ord};
 use kinds::marker;
 use ops::{Deref, Drop};
@@ -118,13 +118,6 @@ impl<T> Clone for Rc<T> {
     }
 }
 
-impl<T: DeepClone> DeepClone for Rc<T> {
-    #[inline]
-    fn deep_clone(&self) -> Rc<T> {
-        Rc::new(self.borrow().deep_clone())
-    }
-}
-
 impl<T: Eq> Eq for Rc<T> {
     #[inline(always)]
     fn eq(&self, other: &Rc<T>) -> bool { *self.borrow() == *other.borrow() }
@@ -211,16 +204,6 @@ mod tests {
     }
 
     #[test]
-    fn test_deep_clone() {
-        let x = Rc::new(RefCell::new(5));
-        let y = x.deep_clone();
-        x.borrow().with_mut(|inner| {
-            *inner = 20;
-        });
-        assert_eq!(y.borrow().with(|v| *v), 5);
-    }
-
-    #[test]
     fn test_simple() {
         let x = Rc::new(5);
         assert_eq!(*x.borrow(), 5);
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index 3f09351ead6..5c3a587d989 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -16,7 +16,7 @@ use iter::{Iterator, FromIterator};
 use option::{None, Option, Some};
 
 /// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
-#[deriving(Clone, DeepClone, Eq, Ord, TotalEq, TotalOrd, Show)]
+#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Show)]
 #[must_use]
 pub enum Result<T, E> {
     /// Contains the success value
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 20aaafbe677..3464c4a1128 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -85,7 +85,7 @@ use cast;
 use cast::transmute;
 use char;
 use char::Char;
-use clone::{Clone, DeepClone};
+use clone::Clone;
 use cmp::{Eq, TotalEq, Ord, TotalOrd, Equiv, Ordering};
 use container::{Container, Mutable};
 use fmt;
@@ -1326,16 +1326,6 @@ impl<'a> Clone for MaybeOwned<'a> {
     }
 }
 
-impl<'a> DeepClone for MaybeOwned<'a> {
-    #[inline]
-    fn deep_clone(&self) -> MaybeOwned<'a> {
-        match *self {
-            Slice(s) => Slice(s),
-            Owned(ref s) => Owned(s.to_owned())
-        }
-    }
-}
-
 impl<'a> Default for MaybeOwned<'a> {
     #[inline]
     fn default() -> MaybeOwned<'a> { Slice("") }
@@ -3031,13 +3021,6 @@ impl Clone for ~str {
     }
 }
 
-impl DeepClone for ~str {
-    #[inline]
-    fn deep_clone(&self) -> ~str {
-        self.to_owned()
-    }
-}
-
 impl FromIterator<char> for ~str {
     #[inline]
     fn from_iterator<T: Iterator<char>>(iterator: &mut T) -> ~str {
@@ -4465,16 +4448,9 @@ mod tests {
     #[test]
     fn test_maybe_owned_clone() {
         assert_eq!(Owned(~"abcde"), Slice("abcde").clone());
-        assert_eq!(Owned(~"abcde"), Slice("abcde").deep_clone());
-
         assert_eq!(Owned(~"abcde"), Owned(~"abcde").clone());
-        assert_eq!(Owned(~"abcde"), Owned(~"abcde").deep_clone());
-
         assert_eq!(Slice("abcde"), Slice("abcde").clone());
-        assert_eq!(Slice("abcde"), Slice("abcde").deep_clone());
-
         assert_eq!(Slice("abcde"), Owned(~"abcde").clone());
-        assert_eq!(Slice("abcde"), Owned(~"abcde").deep_clone());
     }
 
     #[test]
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 69bf5f5d0fc..8080f57550b 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -104,7 +104,7 @@ There are a number of free functions that create or take vectors, for example:
 use cast;
 use cast::transmute;
 use ops::Drop;
-use clone::{Clone, DeepClone};
+use clone::Clone;
 use container::{Container, Mutable};
 use cmp::{Eq, TotalOrd, Ordering, Less, Equal, Greater};
 use cmp;
@@ -2635,24 +2635,6 @@ impl<A: Clone> Clone for ~[A] {
     }
 }
 
-impl<A: DeepClone> DeepClone for ~[A] {
-    #[inline]
-    fn deep_clone(&self) -> ~[A] {
-        self.iter().map(|item| item.deep_clone()).collect()
-    }
-
-    fn deep_clone_from(&mut self, source: &~[A]) {
-        if self.len() < source.len() {
-            *self = source.deep_clone()
-        } else {
-            self.truncate(source.len());
-            for (x, y) in self.mut_iter().zip(source.iter()) {
-                x.deep_clone_from(y);
-            }
-        }
-    }
-}
-
 impl<'a, T: fmt::Show> fmt::Show for &'a [T] {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(f.buf, "["));