Test fixes and rebase conflicts

Also some tidying up of a bunch of crate attributes

Author: alexcrichton

src/compiletest/compiletest.rs

@@ -9,21 +9,20 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-#![allow(unknown_features)]
-#![feature(slicing_syntax, unboxed_closures)]
+
 #![feature(box_syntax)]
+#![feature(collections)]
+#![feature(core)]
 #![feature(int_uint)]
-#![feature(test)]
-#![feature(rustc_private)]
-#![feature(std_misc)]
-#![feature(path)]
 #![feature(io)]
-#![feature(core)]
-#![feature(collections)]
 #![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(slicing_syntax, unboxed_closures)]
+#![feature(std_misc)]
+#![feature(test)]
 #![feature(unicode)]
 
-#![allow(unstable)]
 #![deny(warnings)]
 
 extern crate test;

src/doc/trpl/patterns.md

@@ -180,7 +180,7 @@ If you want to match against a slice or array, you can use `&`:
 fn main() {
     let v = vec!["match_this", "1"];
 
-    match &v {
+    match &v[] {
         ["match_this", second] => println!("The second element is {}", second),
         _ => {},
     }

src/driver/driver.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![allow(unknown_features)]
 #![cfg_attr(rustc, feature(rustc_private))]
 #![cfg_attr(rustdoc, feature(rustdoc))]
 

src/liballoc/lib.rs

@@ -66,11 +66,10 @@
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 
 #![no_std]
-#![allow(unknown_features)]
 #![feature(lang_items, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(optin_builtin_traits)]
-#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(int_uint)]
 #![feature(core)]
 #![feature(hash)]
 #![feature(libc)]

src/libarena/lib.rs

@@ -21,24 +21,21 @@
 
 #![crate_name = "arena"]
 #![unstable(feature = "rustc_private")]
-#![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 
-#![allow(unknown_features)]
-#![feature(unsafe_destructor)]
-#![feature(unboxed_closures)]
-#![feature(box_syntax)]
-#![allow(unknown_features)] #![feature(int_uint)]
-#![allow(missing_docs)]
 #![feature(alloc)]
+#![feature(box_syntax)]
 #![feature(core)]
+#![feature(int_uint)]
+#![feature(staged_api)]
+#![feature(unboxed_closures)]
+#![feature(unsafe_destructor)]
 #![cfg_attr(test, feature(test))]
-#![cfg_attr(test, feature(collections))]
 
 extern crate alloc;
 

src/libcollections/lib.rs

@@ -15,27 +15,27 @@
 
 #![crate_name = "collections"]
 #![unstable(feature = "collections")]
-#![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 
-#![allow(unknown_features)]
-#![feature(unsafe_destructor, slicing_syntax)]
+#![cfg_attr(not(stage0), allow(unused_mut))] // NOTE: remove after stage0 snap
+
+#![feature(alloc)]
 #![feature(box_syntax)]
-#![feature(unboxed_closures)]
-#![allow(unknown_features)] #![feature(int_uint)]
-#![no_std]
 #![feature(core)]
-#![feature(alloc)]
-#![feature(unicode)]
 #![feature(hash)]
+#![feature(int_uint)]
+#![feature(staged_api)]
+#![feature(unboxed_closures)]
+#![feature(unicode)]
+#![feature(unsafe_destructor, slicing_syntax)]
 #![cfg_attr(test, feature(test))]
-// NOTE(stage0): remove after a snapshot
-#![cfg_attr(not(stage0), allow(unused_mut))]
+
+#![no_std]
 
 #[macro_use]
 extern crate core;

src/libcollections/ring_buf.rs

@@ -2204,7 +2204,7 @@ mod tests {
                 d.push_back(i);
             }
 
-            assert_eq!(d.drain().collect::<Vec<i32>>(), [0, 1, 2, 3, 4]);
+            assert_eq!(d.drain().collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
             assert!(d.is_empty());
         }
 
@@ -2214,21 +2214,21 @@ mod tests {
             for i in 0..5 {
                 d.push_back(i);
             }
-            for i in 6i..9 {
+            for i in 6..9 {
                 d.push_front(i);
             }
 
-            assert_eq!(d.drain().collect::<Vec<i32>>(), [8,7,6,0,1,2,3,4]);
+            assert_eq!(d.drain().collect::<Vec<_>>(), [8,7,6,0,1,2,3,4]);
             assert!(d.is_empty());
         }
 
         // partially used
         {
-            let mut d = RingBuf::new();
+            let mut d: RingBuf<i32> = RingBuf::new();
             for i in 0..5 {
                 d.push_back(i);
             }
-            for i in 6i..9 {
+            for i in 6..9 {
                 d.push_front(i);
             }
 
@@ -2669,7 +2669,7 @@ mod tests {
     #[test]
     fn test_as_slices() {
         let mut ring: RingBuf<i32> = RingBuf::with_capacity(127);
-        let cap = ring.capacity() as int;
+        let cap = ring.capacity() as i32;
         let first = cap/2;
         let last  = cap - first;
         for i in 0..first {
@@ -2690,14 +2690,14 @@ mod tests {
             assert_eq!(right, expected_right);
         }
 
-        assert_eq!(ring.len() as int, cap);
-        assert_eq!(ring.capacity() as int, cap);
+        assert_eq!(ring.len() as i32, cap);
+        assert_eq!(ring.capacity() as i32, cap);
     }
 
     #[test]
     fn test_as_mut_slices() {
         let mut ring: RingBuf<i32> = RingBuf::with_capacity(127);
-        let cap = ring.capacity() as int;
+        let cap = ring.capacity() as i32;
         let first = cap/2;
         let last  = cap - first;
         for i in 0..first {
@@ -2718,7 +2718,7 @@ mod tests {
             assert_eq!(right, expected_right);
         }
 
-        assert_eq!(ring.len() as int, cap);
-        assert_eq!(ring.capacity() as int, cap);
+        assert_eq!(ring.len() as i32, cap);
+        assert_eq!(ring.capacity() as i32, cap);
     }
 }

src/libcollections/vec.rs

@@ -181,7 +181,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let mut vec: Vec<int> = Vec::with_capacity(10);
+    /// let mut vec: Vec<_> = Vec::with_capacity(10);
     ///
     /// // The vector contains no items, even though it has capacity for more
     /// assert_eq!(vec.len(), 0);

src/libcore/lib.rs

@@ -49,7 +49,6 @@
 
 #![crate_name = "core"]
 #![unstable(feature = "core")]
-#![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -58,15 +57,16 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![no_std]
-#![allow(unknown_features, raw_pointer_derive)]
-#![allow(unknown_features)] #![feature(intrinsics, lang_items)]
+#![allow(raw_pointer_derive)]
+#![deny(missing_docs)]
+#![cfg_attr(not(stage0), allow(unused_mut))] // NOTE: remove after stage0 snap
+
+#![feature(int_uint)]
+#![feature(intrinsics, lang_items)]
+#![feature(on_unimplemented)]
 #![feature(simd, unsafe_destructor, slicing_syntax)]
+#![feature(staged_api)]
 #![feature(unboxed_closures)]
-#![allow(unknown_features)] #![feature(int_uint)]
-#![feature(on_unimplemented)]
-#![deny(missing_docs)]
-// NOTE(stage0) remove cfg_attr after a snapshot
-#![cfg_attr(not(stage0), allow(unused_mut))]
 
 #[macro_use]
 mod macros;

src/libcore/num/mod.rs

@@ -1728,11 +1728,11 @@ from_str_radix_int_impl! { u32 }
 from_str_radix_int_impl! { u64 }
 
 /// An error which can be returned when parsing an integer.
-#[derive(Show, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct ParseIntError { kind: IntErrorKind }
 
-#[derive(Show, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 enum IntErrorKind {
     Empty,
     InvalidDigit,
@@ -1760,11 +1760,11 @@ impl Error for ParseIntError {
 }
 
 /// An error which can be returned when parsing a float.
-#[derive(Show, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct ParseFloatError { kind: FloatErrorKind }
 
-#[derive(Show, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 enum FloatErrorKind {
     Empty,
     Invalid,