auto merge of #12706 : pongad/rust/issue_12698, r=brson

Fixes #12698

Author: bors

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();

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;
@@ -241,14 +153,6 @@ fn test_clone_from() {
     assert_eq!(*b, 5);
 }
 
-#[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 {}
@@ -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();
 }

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::*;
@@ -104,16 +93,6 @@ mod tests {
         assert_eq!(y.borrow().with(|x| *x), 20);
     }
 
-    #[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);

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
 }

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

src/libstd/option.rs

@@ -39,16 +39,15 @@
 
 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;
 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>
 }

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

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),

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};

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() }
@@ -210,16 +203,6 @@ mod tests {
         assert_eq!(y.borrow().with(|v| *v), 20);
     }
 
-    #[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);