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,

src/libcore/str/mod.rs

@@ -148,7 +148,7 @@ impl FromStr for bool {
 }
 
 /// An error returned when parsing a `bool` from a string fails.
-#[derive(Show, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 #[allow(missing_copy_implementations)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct ParseBoolError { _priv: () }

src/libcoretest/hash/mod.rs

@@ -76,12 +76,12 @@ fn test_writer_hasher() {
     // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]>
 
     unsafe {
-        let ptr: *const int = mem::transmute(5);
+        let ptr: *const i32 = mem::transmute(5is);
         assert_eq!(hash(&ptr), 5);
     }
 
     unsafe {
-        let ptr: *mut int = mem::transmute(5);
+        let ptr: *mut i32 = mem::transmute(5is);
         assert_eq!(hash(&ptr), 5);
     }
 }

src/libcoretest/iter.rs

@@ -328,15 +328,15 @@ fn test_iterator_len() {
 
 #[test]
 fn test_iterator_sum() {
-    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     assert_eq!(v[..4].iter().map(|&x| x).sum(), 6);
     assert_eq!(v.iter().map(|&x| x).sum(), 55);
     assert_eq!(v[..0].iter().map(|&x| x).sum(), 0);
 }
 
 #[test]
 fn test_iterator_product() {
-    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     assert_eq!(v[..4].iter().map(|&x| x).product(), 0);
     assert_eq!(v[1..5].iter().map(|&x| x).product(), 24);
     assert_eq!(v[..0].iter().map(|&x| x).product(), 1);
@@ -730,23 +730,23 @@ fn test_random_access_cycle() {
 
 #[test]
 fn test_double_ended_range() {
-    assert!((11..14).rev().collect::<Vec<int>>() == vec![13, 12, 11]);
+    assert!((11..14).rev().collect::<Vec<_>>() == vec![13, 12, 11]);
     for _ in (10..0).rev() {
         panic!("unreachable");
     }
 
-    assert!((11u..14).rev().collect::<Vec<uint>>() == vec![13u, 12, 11]);
-    for _ in (10u..0).rev() {
+    assert!((11..14).rev().collect::<Vec<_>>() == vec![13, 12, 11]);
+    for _ in (10..0).rev() {
         panic!("unreachable");
     }
 }
 
 #[test]
 fn test_range() {
-    assert!((0..5).collect::<Vec<int>>() == vec![0, 1, 2, 3, 4]);
-    assert!((-10..-1).collect::<Vec<int>>() ==
+    assert!((0..5).collect::<Vec<_>>() == vec![0, 1, 2, 3, 4]);
+    assert!((-10..-1).collect::<Vec<_>>() ==
                vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
-    assert!((0..5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
+    assert!((0..5).rev().collect::<Vec<_>>() == vec![4, 3, 2, 1, 0]);
     assert_eq!((200..-5).count(), 0);
     assert_eq!((200..-5).rev().count(), 0);
     assert_eq!((200..200).count(), 0);

src/libcoretest/lib.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(unsafe_destructor, slicing_syntax)]
-#![feature(unboxed_closures)]
 #![feature(box_syntax)]
-#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(int_uint)]
+#![feature(unboxed_closures)]
+#![feature(unsafe_destructor, slicing_syntax)]
 
 extern crate core;
 extern crate test;

src/libflate/lib.rs

@@ -16,17 +16,17 @@
 
 #![crate_name = "flate"]
 #![unstable(feature = "rustc_private")]
-#![feature(staged_api)]
 #![staged_api]
-#![allow(unknown_features)] #![feature(int_uint)]
 #![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/")]
-#![feature(hash)]
+
 #![feature(core)]
+#![feature(int_uint)]
 #![feature(libc)]
+#![feature(staged_api)]
 
 #[cfg(test)] #[macro_use] extern crate log;
 

src/libfmt_macros/lib.rs

@@ -16,7 +16,6 @@
 
 #![crate_name = "fmt_macros"]
 #![unstable(feature = "rustc_private")]
-#![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
@@ -25,10 +24,10 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 
+#![cfg_attr(stage0, feature(core))]
+#![feature(int_uint)]
 #![feature(slicing_syntax)]
-#![allow(unknown_features)] #![feature(int_uint)]
-#![feature(collections)]
-#![feature(core)]
+#![feature(staged_api)]
 #![feature(unicode)]
 
 pub use self::Piece::*;