---

yaml
---
r: 162316
b: refs/heads/auto
c: 8ebc1c9
h: refs/heads/master
v: v3

Author: luqmana

[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: 39b57115fbf5d91df3382699b1dbde7ea8716f6c
+refs/heads/auto: 8ebc1c9fd88640b1833e0743b649a957f3337720
 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/guide.md

@@ -3681,8 +3681,8 @@ Here's the second note, which lets us know where the first borrow would be over.
 This is useful, because if we wait to try to borrow `x` after this borrow is
 over, then everything will work.
 
-For more advanced patterns, please consult the [Ownership
-Guide](guide-ownership.html).  You'll also learn what this type signature with
+For more advanced patterns, please consult the [Lifetime
+Guide](guide-lifetimes.html).  You'll also learn what this type signature with
 the `'a` syntax is:
 
 ```{rust,ignore}

branches/auto/src/doc/reference.md

@@ -994,7 +994,7 @@ An example of `use` declarations:
 
 ```
 use std::iter::range_step;
-use std::option::Option::{Some, None};
+use std::option::{Some, None};
 use std::collections::hash_map::{mod, HashMap};
 
 fn foo<T>(_: T){}
@@ -1004,8 +1004,8 @@ fn main() {
     // Equivalent to 'std::iter::range_step(0u, 10u, 2u);'
     range_step(0u, 10u, 2u);
 
-    // Equivalent to 'foo(vec![std::option::Option::Some(1.0f64),
-    // std::option::Option::None]);'
+    // Equivalent to 'foo(vec![std::option::Some(1.0f64),
+    // std::option::None]);'
     foo(vec![Some(1.0f64), None]);
 
     // Both `hash_map` and `HashMap` are in scope.
@@ -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/etc/unicode.py

@@ -292,7 +292,7 @@ def escape_char(c):
 def emit_bsearch_range_table(f):
     f.write("""
 fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
-    use core::cmp::Ordering::{Equal, Less, Greater};
+    use core::cmp::{Equal, Less, Greater};
     use core::slice::SlicePrelude;
     r.binary_search(|&(lo,hi)| {
         if lo <= c && c <= hi { Equal }
@@ -350,11 +350,10 @@ def emit_regex_module(f, cats, w_data):
 def emit_conversions_module(f, lowerupper, upperlower):
     f.write("pub mod conversions {")
     f.write("""
-    use core::cmp::Ordering::{Equal, Less, Greater};
+    use core::cmp::{Equal, Less, Greater};
     use core::slice::SlicePrelude;
     use core::tuple::Tuple2;
-    use core::option::Option;
-    use core::option::Option::{Some, None};
+    use core::option::{Option, Some, None};
     use core::slice;
 
     pub fn to_lower(c: char) -> char {
@@ -404,7 +403,7 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
     f.write("""    }
 
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
-        use core::cmp::Ordering::{Equal, Less, Greater};
+        use core::cmp::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
@@ -431,13 +430,12 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
 
 def emit_charwidth_module(f, width_table):
     f.write("pub mod charwidth {\n")
-    f.write("    use core::option::Option;\n")
-    f.write("    use core::option::Option::{Some, None};\n")
+    f.write("    use core::option::{Option, Some, None};\n")
     f.write("    use core::slice::SlicePrelude;\n")
     f.write("    use core::slice;\n")
     f.write("""
     fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {
-        use core::cmp::Ordering::{Equal, Less, Greater};
+        use core::cmp::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
@@ -532,7 +530,7 @@ def comp_pfun(char):
 
     f.write("""
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
-        use core::cmp::Ordering::{Equal, Less, Greater};
+        use core::cmp::{Equal, Less, Greater};
         use core::slice::SlicePrelude;
         use core::slice;
         match r.binary_search(|&(lo, hi, _)| {

branches/auto/src/liballoc/arc.rs

@@ -22,8 +22,7 @@ use core::kinds::{Sync, Send};
 use core::mem::{min_align_of, size_of, drop};
 use core::mem;
 use core::ops::{Drop, Deref};
-use core::option::Option;
-use core::option::Option::{Some, None};
+use core::option::{Some, None, Option};
 use core::ptr::RawPtr;
 use core::ptr;
 use heap::deallocate;
@@ -327,8 +326,7 @@ mod tests {
     use std::comm::channel;
     use std::mem::drop;
     use std::ops::Drop;
-    use std::option::Option;
-    use std::option::Option::{Some, None};
+    use std::option::{Option, Some, None};
     use std::str::Str;
     use std::sync::atomic;
     use std::task;
@@ -523,7 +521,7 @@ mod tests {
     #[test]
     fn show_arc() {
         let a = Arc::new(5u32);
-        assert!(format!("{}", a) == "5")
+        assert!(format!("{}", a).as_slice() == "5")
     }
 
     // Make sure deriving works with Arc<T>

branches/auto/src/liballoc/boxed.rs

@@ -19,8 +19,7 @@ use core::kinds::Sized;
 use core::mem;
 use core::option::Option;
 use core::raw::TraitObject;
-use core::result::Result;
-use core::result::Result::{Ok, Err};
+use core::result::{Ok, Err, Result};
 
 /// A value that represents the global exchange heap. This is the default
 /// place that the `box` keyword allocates into when no place is supplied.
@@ -170,14 +169,14 @@ mod test {
         let b = box Test as Box<Any>;
         let a_str = a.to_str();
         let b_str = b.to_str();
-        assert_eq!(a_str, "Box<Any>");
-        assert_eq!(b_str, "Box<Any>");
+        assert_eq!(a_str.as_slice(), "Box<Any>");
+        assert_eq!(b_str.as_slice(), "Box<Any>");
 
         let a = &8u as &Any;
         let b = &Test as &Any;
         let s = format!("{}", a);
-        assert_eq!(s, "&Any");
+        assert_eq!(s.as_slice(), "&Any");
         let s = format!("{}", b);
-        assert_eq!(s, "&Any");
+        assert_eq!(s.as_slice(), "&Any");
     }
 }

branches/auto/src/liballoc/heap.rs

@@ -177,8 +177,7 @@ mod imp {
 
 #[cfg(all(not(external_funcs), not(external_crate), jemalloc))]
 mod imp {
-    use core::option::Option;
-    use core::option::Option::None;
+    use core::option::{None, Option};
     use core::ptr::{null_mut, null};
     use core::num::Int;
     use libc::{c_char, c_int, c_void, size_t};

branches/auto/src/liballoc/rc.rs

@@ -149,12 +149,10 @@ use core::fmt;
 use core::kinds::marker;
 use core::mem::{transmute, min_align_of, size_of, forget};
 use core::ops::{Deref, Drop};
-use core::option::Option;
-use core::option::Option::{Some, None};
+use core::option::{Option, Some, None};
 use core::ptr;
 use core::ptr::RawPtr;
-use core::result::Result;
-use core::result::Result::{Ok, Err};
+use core::result::{Result, Ok, Err};
 
 use heap::deallocate;
 
@@ -741,9 +739,8 @@ impl<T> RcBoxPtr<T> for Weak<T> {
 mod tests {
     use super::{Rc, Weak, weak_count, strong_count};
     use std::cell::RefCell;
-    use std::option::Option;
-    use std::option::Option::{Some, None};
-    use std::result::Result::{Err, Ok};
+    use std::option::{Option, Some, None};
+    use std::result::{Err, Ok};
     use std::mem::drop;
     use std::clone::Clone;
 

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.
@@ -487,7 +485,7 @@ impl<T: Ord> BinaryHeap<T> {
         let mut end = q.len();
         while end > 1 {
             end -= 1;
-            q.data.swap(0, end);
+            q.data.as_mut_slice().swap(0, end);
             q.siftdown_range(0, end)
         }
         q.into_vec()
@@ -771,8 +769,8 @@ mod tests {
         v.sort();
         data.sort();
 
-        assert_eq!(v, data);
-        assert_eq!(heap.into_sorted_vec(), data);
+        assert_eq!(v.as_slice(), data.as_slice());
+        assert_eq!(heap.into_sorted_vec().as_slice(), data.as_slice());
     }
 
     #[test]
@@ -814,7 +812,7 @@ mod tests {
     fn test_from_iter() {
         let xs = vec!(9u, 8, 7, 6, 5, 4, 3, 2, 1);
 
-        let mut q: BinaryHeap<uint> = xs.iter().rev().map(|&x| x).collect();
+        let mut q: BinaryHeap<uint> = xs.as_slice().iter().rev().map(|&x| x).collect();
 
         for &x in xs.iter() {
             assert_eq!(q.pop().unwrap(), x);

branches/auto/src/libcollections/bit.rs

@@ -1692,10 +1692,10 @@ mod tests {
     #[test]
     fn test_to_str() {
         let zerolen = Bitv::new();
-        assert_eq!(zerolen.to_string(), "");
+        assert_eq!(zerolen.to_string().as_slice(), "");
 
         let eightbits = Bitv::with_capacity(8u, false);
-        assert_eq!(eightbits.to_string(), "00000000")
+        assert_eq!(eightbits.to_string().as_slice(), "00000000")
     }
 
     #[test]
@@ -1718,7 +1718,7 @@ mod tests {
         let mut b = bitv::Bitv::with_capacity(2, false);
         b.set(0, true);
         b.set(1, false);
-        assert_eq!(b.to_string(), "10");
+        assert_eq!(b.to_string().as_slice(), "10");
     }
 
     #[test]
@@ -2029,7 +2029,7 @@ mod tests {
     fn test_from_bytes() {
         let bitv = from_bytes(&[0b10110110, 0b00000000, 0b11111111]);
         let str = format!("{}{}{}", "10110110", "00000000", "11111111");
-        assert_eq!(bitv.to_string(), str);
+        assert_eq!(bitv.to_string().as_slice(), str.as_slice());
     }
 
     #[test]
@@ -2048,7 +2048,7 @@ mod tests {
     fn test_from_bools() {
         let bools = vec![true, false, true, true];
         let bitv: Bitv = bools.iter().map(|n| *n).collect();
-        assert_eq!(bitv.to_string(), "1011");
+        assert_eq!(bitv.to_string().as_slice(), "1011");
     }
 
     #[test]
@@ -2207,7 +2207,7 @@ mod tests {
 
         let expected = [3, 5, 11, 77];
         let actual = a.intersection(&b).collect::<Vec<uint>>();
-        assert_eq!(actual, expected);
+        assert_eq!(actual.as_slice(), expected.as_slice());
     }
 
     #[test]
@@ -2226,7 +2226,7 @@ mod tests {
 
         let expected = [1, 5, 500];
         let actual = a.difference(&b).collect::<Vec<uint>>();
-        assert_eq!(actual, expected);
+        assert_eq!(actual.as_slice(), expected.as_slice());
     }
 
     #[test]
@@ -2247,7 +2247,7 @@ mod tests {
 
         let expected = [1, 5, 11, 14, 220];
         let actual = a.symmetric_difference(&b).collect::<Vec<uint>>();
-        assert_eq!(actual, expected);
+        assert_eq!(actual.as_slice(), expected.as_slice());
     }
 
     #[test]
@@ -2272,7 +2272,7 @@ mod tests {
 
         let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160, 200];
         let actual = a.union(&b).collect::<Vec<uint>>();
-        assert_eq!(actual, expected);
+        assert_eq!(actual.as_slice(), expected.as_slice());
     }
 
     #[test]
@@ -2660,7 +2660,7 @@ mod tests {
         s.insert(10);
         s.insert(50);
         s.insert(2);
-        assert_eq!("{1, 2, 10, 50}", s.to_string());
+        assert_eq!("{1, 2, 10, 50}".to_string(), s.to_string());
     }
 
     fn rng() -> rand::IsaacRng {