---

yaml
---
r: 162307
b: refs/heads/auto
c: 87edbea
h: refs/heads/master
i:
  162305: a6b1cbc
  162303: ff936b0
v: v3

Author: nikomatsakis

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: cafe2966770ff377aad6dd9fd808e68055587c58
+refs/heads/auto: 87edbea9da1d7dfd7e8c68e15f846f08d5f3a8c0
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/common.rs

@@ -25,8 +25,6 @@ pub enum Mode {
     Codegen
 }
 
-impl Copy for Mode {}
-
 impl FromStr for Mode {
     fn from_str(s: &str) -> Option<Mode> {
         match s {

branches/auto/src/doc/guide-unsafe.md

@@ -661,9 +661,6 @@ extern {
     fn abort() -> !;
 }
 
-#[lang = "owned_box"]
-pub struct Box<T>(*mut T);
-
 #[lang="exchange_malloc"]
 unsafe fn allocate(size: uint, _align: uint) -> *mut u8 {
     let p = libc::malloc(size as libc::size_t) as *mut u8;

branches/auto/src/doc/reference.md

@@ -1660,7 +1660,6 @@ Implementations are defined with the keyword `impl`.
 
 ```
 # struct Point {x: f64, y: f64};
-# impl Copy for Point {}
 # type Surface = int;
 # struct BoundingBox {x: f64, y: f64, width: f64, height: f64};
 # trait Shape { fn draw(&self, Surface); fn bounding_box(&self) -> BoundingBox; }
@@ -1670,8 +1669,6 @@ struct Circle {
     center: Point,
 }
 
-impl Copy for Circle {}
-
 impl Shape for Circle {
     fn draw(&self, s: Surface) { do_draw_circle(s, *self); }
     fn bounding_box(&self) -> BoundingBox {
@@ -1794,7 +1791,6 @@ default visibility with the `priv` keyword. When an item is declared as `pub`,
 it can be thought of as being accessible to the outside world. For example:
 
 ```
-# #![allow(missing_copy_implementations)]
 # fn main() {}
 // Declare a private struct
 struct Foo;

branches/auto/src/libarena/lib.rs

@@ -466,7 +466,7 @@ impl<T> TypedArena<T> {
         }
 
         let ptr: &mut T = unsafe {
-            let ptr: &mut T = mem::transmute(self.ptr.clone());
+            let ptr: &mut T = mem::transmute(self.ptr);
             ptr::write(ptr, object);
             self.ptr.set(self.ptr.get().offset(1));
             ptr

branches/auto/src/libcollections/binary_heap.rs

@@ -35,8 +35,6 @@
 //!     position: uint
 //! }
 //!
-//! impl Copy for State {}
-//!
 //! // The priority queue depends on `Ord`.
 //! // Explicitly implement the trait so the queue becomes a min-heap
 //! // instead of a max-heap.

branches/auto/src/libcollections/dlist.rs

@@ -39,12 +39,7 @@ pub struct DList<T> {
 }
 
 type Link<T> = Option<Box<Node<T>>>;
-
-struct Rawlink<T> {
-    p: *mut T,
-}
-
-impl<T> Copy for Rawlink<T> {}
+struct Rawlink<T> { p: *mut T }
 
 struct Node<T> {
     next: Link<T>,
@@ -64,8 +59,6 @@ impl<'a, T> Clone for Items<'a, T> {
     fn clone(&self) -> Items<'a, T> { *self }
 }
 
-impl<'a,T> Copy for Items<'a,T> {}
-
 /// An iterator over mutable references to the items of a `DList`.
 pub struct MutItems<'a, T:'a> {
     list: &'a mut DList<T>,

branches/auto/src/libcollections/enum_set.rs

@@ -27,8 +27,6 @@ pub struct EnumSet<E> {
     bits: uint
 }
 
-impl<E> Copy for EnumSet<E> {}
-
 impl<E:CLike+fmt::Show> fmt::Show for EnumSet<E> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(fmt, "{{"));
@@ -271,8 +269,6 @@ mod test {
         A, B, C
     }
 
-    impl Copy for Foo {}
-
     impl CLike for Foo {
         fn to_uint(&self) -> uint {
             *self as uint
@@ -481,9 +477,6 @@ mod test {
             V50, V51, V52, V53, V54, V55, V56, V57, V58, V59,
             V60, V61, V62, V63, V64, V65, V66, V67, V68, V69,
         }
-
-        impl Copy for Bar {}
-
         impl CLike for Bar {
             fn to_uint(&self) -> uint {
                 *self as uint

branches/auto/src/libcollections/hash/sip.rs

@@ -43,8 +43,6 @@ pub struct SipState {
     ntail: uint,  // how many bytes in tail are valid
 }
 
-impl Copy for SipState {}
-
 // sadly, these macro definitions can't appear later,
 // because they're needed in the following defs;
 // this design could be improved.
@@ -213,7 +211,6 @@ impl Default for SipState {
 
 /// `SipHasher` computes the SipHash algorithm from a stream of bytes.
 #[deriving(Clone)]
-#[allow(missing_copy_implementations)]
 pub struct SipHasher {
     k0: u64,
     k1: u64,

branches/auto/src/libcollections/slice.rs

@@ -91,7 +91,7 @@ use self::Direction::*;
 use alloc::boxed::Box;
 use core::borrow::{BorrowFrom, BorrowFromMut, ToOwned};
 use core::cmp;
-use core::kinds::{Copy, Sized};
+use core::kinds::Sized;
 use core::mem::size_of;
 use core::mem;
 use core::prelude::{Clone, Greater, Iterator, IteratorExt, Less, None, Option};
@@ -177,16 +177,12 @@ impl ElementSwaps {
 
 enum Direction { Pos, Neg }
 
-impl Copy for Direction {}
-
 /// An `Index` and `Direction` together.
 struct SizeDirection {
     size: uint,
     dir: Direction,
 }
 
-impl Copy for SizeDirection {}
-
 impl Iterator<(uint, uint)> for ElementSwaps {
     #[inline]
     fn next(&mut self) -> Option<(uint, uint)> {
@@ -1486,17 +1482,11 @@ mod tests {
             fn clone(&self) -> S {
                 self.f.set(self.f.get() + 1);
                 if self.f.get() == 10 { panic!() }
-                S {
-                    f: self.f.clone(),
-                    boxes: self.boxes.clone(),
-                }
+                S { f: self.f, boxes: self.boxes.clone() }
             }
         }
 
-        let s = S {
-            f: Cell::new(0),
-            boxes: (box 0, Rc::new(0)),
-        };
+        let s = S { f: Cell::new(0), boxes: (box 0, Rc::new(0)) };
         let _ = Vec::from_elem(100, s);
     }
 

branches/auto/src/libcollections/str.rs

@@ -228,32 +228,24 @@ impl<'a> Iterator<char> for Decompositions<'a> {
             _ => self.sorted = false
         }
 
+        let decomposer = match self.kind {
+            Canonical => unicode::char::decompose_canonical,
+            Compatible => unicode::char::decompose_compatible
+        };
+
         if !self.sorted {
             for ch in self.iter {
                 let buffer = &mut self.buffer;
                 let sorted = &mut self.sorted;
-                {
-                    let callback = |d| {
-                        let class =
-                            unicode::char::canonical_combining_class(d);
-                        if class == 0 && !*sorted {
-                            canonical_sort(buffer.as_mut_slice());
-                            *sorted = true;
-                        }
-                        buffer.push((d, class));
-                    };
-                    match self.kind {
-                        Canonical => {
-                            unicode::char::decompose_canonical(ch, callback)
-                        }
-                        Compatible => {
-                            unicode::char::decompose_compatible(ch, callback)
-                        }
+                decomposer(ch, |d| {
+                    let class = unicode::char::canonical_combining_class(d);
+                    if class == 0 && !*sorted {
+                        canonical_sort(buffer.as_mut_slice());
+                        *sorted = true;
                     }
-                }
-                if *sorted {
-                    break
-                }
+                    buffer.push((d, class));
+                });
+                if *sorted { break }
             }
         }
 

branches/auto/src/libcollections/vec.rs

@@ -682,12 +682,11 @@ impl<T> Vec<T> {
                 Some(new_cap) => {
                     let amort_cap = new_cap.next_power_of_two();
                     // next_power_of_two will overflow to exactly 0 for really big capacities
-                    let cap = if amort_cap == 0 {
-                        new_cap
+                    if amort_cap == 0 {
+                        self.grow_capacity(new_cap);
                     } else {
-                        amort_cap
-                    };
-                    self.grow_capacity(cap)
+                        self.grow_capacity(amort_cap);
+                    }
                 }
             }
         }

branches/auto/src/libcore/atomic.rs

@@ -17,7 +17,6 @@ pub use self::Ordering::*;
 use intrinsics;
 use std::kinds::marker;
 use cell::UnsafeCell;
-use kinds::Copy;
 
 /// A boolean type which can be safely shared between threads.
 #[stable]
@@ -82,8 +81,6 @@ pub enum Ordering {
     SeqCst,
 }
 
-impl Copy for Ordering {}
-
 /// An `AtomicBool` initialized to `false`.
 #[unstable = "may be renamed, pending conventions for static initalizers"]
 pub const INIT_ATOMIC_BOOL: AtomicBool =

branches/auto/src/libcore/char.rs

@@ -519,4 +519,3 @@ impl Iterator<char> for DefaultEscapedChars {
         }
     }
 }
-

branches/auto/src/libcore/cmp.rs

@@ -43,8 +43,9 @@
 
 pub use self::Ordering::*;
 
-use kinds::{Copy, Sized};
-use option::{Option, Some, None};
+use kinds::Sized;
+use option::Option;
+use option::Option::{Some, None};
 
 /// Trait for values that can be compared for equality and inequality.
 ///
@@ -105,8 +106,6 @@ pub enum Ordering {
    Greater = 1i,
 }
 
-impl Copy for Ordering {}
-
 impl Ordering {
     /// Reverse the `Ordering`, so that `Less` becomes `Greater` and
     /// vice versa.

branches/auto/src/libcore/fmt/mod.rs

@@ -46,8 +46,6 @@ pub type Result = result::Result<(), Error>;
 #[experimental = "core and I/O reconciliation may alter this definition"]
 pub struct Error;
 
-impl Copy for Error {}
-
 /// A collection of methods that are required to format a message into a stream.
 ///
 /// This trait is the type which this modules requires when formatting
@@ -137,8 +135,6 @@ impl<'a> Argument<'a> {
     }
 }
 
-impl<'a> Copy for Argument<'a> {}
-
 impl<'a> Arguments<'a> {
     /// When using the format_args!() macro, this function is used to generate the
     /// Arguments structure.

branches/auto/src/libcore/fmt/num.rs

@@ -16,7 +16,6 @@
 
 use fmt;
 use iter::DoubleEndedIteratorExt;
-use kinds::Copy;
 use num::{Int, cast};
 use slice::SlicePrelude;
 
@@ -115,8 +114,6 @@ pub struct Radix {
     base: u8,
 }
 
-impl Copy for Radix {}
-
 impl Radix {
     fn new(base: u8) -> Radix {
         assert!(2 <= base && base <= 36, "the base must be in the range of 2..36: {}", base);
@@ -139,8 +136,6 @@ impl GenericRadix for Radix {
 #[unstable = "may be renamed or move to a different module"]
 pub struct RadixFmt<T, R>(T, R);
 
-impl<T,R> Copy for RadixFmt<T,R> where T: Copy, R: Copy {}
-
 /// Constructs a radix formatter in the range of `2..36`.
 ///
 /// # Example

branches/auto/src/libcore/fmt/rt.rs

@@ -20,16 +20,13 @@ pub use self::Alignment::*;
 pub use self::Count::*;
 pub use self::Position::*;
 pub use self::Flag::*;
-use kinds::Copy;
 
 #[doc(hidden)]
 pub struct Argument<'a> {
     pub position: Position,
     pub format: FormatSpec,
 }
 
-impl<'a> Copy for Argument<'a> {}
-
 #[doc(hidden)]
 pub struct FormatSpec {
     pub fill: char,
@@ -39,8 +36,6 @@ pub struct FormatSpec {
     pub width: Count,
 }
 
-impl Copy for FormatSpec {}
-
 /// Possible alignments that can be requested as part of a formatting directive.
 #[deriving(PartialEq)]
 pub enum Alignment {
@@ -54,22 +49,16 @@ pub enum Alignment {
     AlignUnknown,
 }
 
-impl Copy for Alignment {}
-
 #[doc(hidden)]
 pub enum Count {
     CountIs(uint), CountIsParam(uint), CountIsNextParam, CountImplied,
 }
 
-impl Copy for Count {}
-
 #[doc(hidden)]
 pub enum Position {
     ArgumentNext, ArgumentIs(uint)
 }
 
-impl Copy for Position {}
-
 /// Flags which can be passed to formatting via a directive.
 ///
 /// These flags are discovered through the `flags` field of the `Formatter`
@@ -89,5 +78,3 @@ pub enum Flag {
     /// being aware of the sign to be printed.
     FlagSignAwareZeroPad,
 }
-
-impl Copy for Flag {}