---

yaml
---
r: 162301
b: refs/heads/auto
c: ca4f536
h: refs/heads/master
i:
  162299: 3ec4c21
v: v3

Author: barosl

[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: c56e59c722ac5de216ec70f0d1834963ae197ddb
+refs/heads/auto: ca4f53655e82a0a0e1d613b16108720bb7a50fde
 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/compiletest/compiletest.rs

@@ -346,7 +346,7 @@ pub fn make_test(config: &Config, testfile: &Path, f: || -> test::TestFn)
         desc: test::TestDesc {
             name: make_test_name(config, testfile),
             ignore: header::is_test_ignored(config, testfile),
-            should_fail: test::ShouldFail::No,
+            should_fail: false
         },
         testfn: f(),
     }

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

@@ -89,21 +89,6 @@ fn test_out_of_bounds_failure() {
 }
 ~~~
 
-`#[should_fail]` tests can be fragile as it's hard to guarantee that the test
-didn't fail for an unexpected reason. To help with this, an optional `expected`
-parameter can be added to the `should_fail` attribute. The test harness will
-make sure that the failure message contains the provided text. A safer version
-of the example above would be:
-
-~~~test_harness
-#[test]
-#[should_fail(expected = "index out of bounds")]
-fn test_out_of_bounds_failure() {
-    let v: &[int] = &[];
-    v[0];
-}
-~~~
-
 A test runner built with the `--test` flag supports a limited set of
 arguments to control which tests are run:
 

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/btree/map.rs

@@ -1068,38 +1068,12 @@ impl<K, V> BTreeMap<K, V> {
     }
 
     /// Gets an iterator over the keys of the map.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1u, "a");
-    /// a.insert(2u, "b");
-    ///
-    /// let keys: Vec<uint> = a.keys().cloned().collect();
-    /// assert_eq!(keys, vec![1u,2,]);
-    /// ```
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
         self.iter().map(|(k, _)| k)
     }
 
     /// Gets an iterator over the values of the map.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1u, "a");
-    /// a.insert(2u, "b");
-    ///
-    /// let values: Vec<&str> = a.values().cloned().collect();
-    /// assert_eq!(values, vec!["a","b"]);
-    /// ```
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn values<'a>(&'a self) -> Values<'a, K, V> {
         self.iter().map(|(_, v)| v)

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

@@ -218,9 +218,15 @@ impl<T> Vec<T> {
         }
     }
 
-    /// Creates a `Vec<T>` directly from the raw components of another vector.
+    /// Creates a `Vec<T>` directly from the raw constituents.
     ///
-    /// This is highly unsafe, due to the number of invariants that aren't checked.
+    /// This is highly unsafe:
+    ///
+    /// - if `ptr` is null, then `length` and `capacity` should be 0
+    /// - `ptr` must point to an allocation of size `capacity`
+    /// - there must be `length` valid instances of type `T` at the
+    ///   beginning of that allocation
+    /// - `ptr` must be allocated by the default `Vec` allocator
     ///
     /// # Example
     ///
@@ -682,12 +688,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.