auto merge of #17127 : alexcrichton/rust/rollup, r=alexcrichton

Author: bors

configure

@@ -707,7 +707,7 @@ then
             | cut -d ' ' -f 2)
 
         case $CFG_CLANG_VERSION in
-            (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* )
+            (3.0svn | 3.0 | 3.1* | 3.2* | 3.3* | 3.4* | 3.5* | 3.6*)
             step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
             if [ -z "$CC" ]
             then

src/doc/guide.md

@@ -520,10 +520,8 @@ error: aborting due to previous error
 Could not compile `hello_world`.
 ```
 
-Rust will not let us use a value that has not been initialized. So why let us
-declare a binding without initializing it? You'd think our first example would
-have errored. Well, Rust is smarter than that. Before we get to that, let's talk
-about this stuff we've added to `println!`.
+Rust will not let us use a value that has not been initialized. Next, let's
+talk about this stuff we've added to `println!`.
 
 If you include two curly braces (`{}`, some call them moustaches...) in your
 string to print, Rust will interpret this as a request to interpolate some sort
@@ -538,12 +536,6 @@ format in a more detailed manner, there are a [wide number of options
 available](std/fmt/index.html). For now, we'll just stick to the default:
 integers aren't very complicated to print.
 
-So, we've cleared up all of the confusion around bindings, with one exception:
-why does Rust let us declare a variable binding without an initial value if we
-must initialize the binding before we use it? And how does it know that we have
-or have not initialized the binding? For that, we need to learn our next
-concept: `if`.
-
 # If
 
 Rust's take on `if` is not particularly complex, but it's much more like the
@@ -582,7 +574,6 @@ if x == 5i {
 
 This is all pretty standard. However, you can also do this:
 
-
 ```
 let x = 5i;
 

src/doc/rust.md

@@ -3290,17 +3290,19 @@ between `_` and `..` is that the pattern `C(_)` is only type-correct if `C` has
 exactly one argument, while the pattern `C(..)` is type-correct for any enum
 variant `C`, regardless of how many arguments `C` has.
 
-Used inside a vector pattern, `..` stands for any number of elements. This
-wildcard can be used at most once for a given vector, which implies that it
-cannot be used to specifically match elements that are at an unknown distance
-from both ends of a vector, like `[.., 42, ..]`. If followed by a variable name,
-it will bind the corresponding slice to the variable. Example:
+Used inside a vector pattern, `..` stands for any number of elements, when the
+`advanced_slice_patterns` feature gate is turned on. This wildcard can be used
+at most once for a given vector, which implies that it cannot be used to
+specifically match elements that are at an unknown distance from both ends of a
+vector, like `[.., 42, ..]`.  If followed by a variable name, it will bind the
+corresponding slice to the variable.  Example:
 
 ~~~~
+# #![feature(advanced_slice_patterns)]
 fn is_symmetric(list: &[uint]) -> bool {
     match list {
         [] | [_]                   => true,
-        [x, ..inside, y] if x == y => is_symmetric(inside),
+        [x, inside.., y] if x == y => is_symmetric(inside),
         _                          => false
     }
 }

src/doc/tutorial.md

@@ -1707,7 +1707,7 @@ let score = match numbers {
     [] => 0,
     [a] => a * 10,
     [a, b] => a * 6 + b * 4,
-    [a, b, c, ..rest] => a * 5 + b * 3 + c * 2 + rest.len() as int
+    [a, b, c, rest..] => a * 5 + b * 3 + c * 2 + rest.len() as int
 };
 ~~~~
 

src/etc/licenseck.py

@@ -43,12 +43,15 @@
     "libsync/mpmc_bounded_queue.rs", # BSD
     "libsync/mpsc_intrusive.rs", # BSD
     "test/bench/shootout-binarytrees.rs", # BSD
+    "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD
     "test/bench/shootout-k-nucleotide.rs", # BSD
     "test/bench/shootout-mandelbrot.rs", # BSD
     "test/bench/shootout-meteor.rs", # BSD
+    "test/bench/shootout-nbody.rs", # BSD
     "test/bench/shootout-pidigits.rs", # BSD
     "test/bench/shootout-regex-dna.rs", # BSD
+    "test/bench/shootout-reverse-complement.rs", # BSD
     "test/bench/shootout-threadring.rs", # BSD
 ]
 

src/libarena/lib.rs

@@ -509,6 +509,7 @@ mod tests {
     use self::test::Bencher;
     use super::{Arena, TypedArena};
 
+    #[allow(dead_code)]
     struct Point {
         x: int,
         y: int,
@@ -564,6 +565,7 @@ mod tests {
         })
     }
 
+    #[allow(dead_code)]
     struct Noncopy {
         string: String,
         array: Vec<int>,

src/libcollections/slice.rs

@@ -864,6 +864,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_tailn() {
         let mut a = vec![11i, 12, 13];
         let b: &[int] = &[11, 12, 13];
@@ -875,6 +876,7 @@ mod tests {
 
     #[test]
     #[should_fail]
+    #[allow(deprecated)]
     fn test_tailn_empty() {
         let a: Vec<int> = vec![];
         a.tailn(2);
@@ -909,6 +911,7 @@ mod tests {
 
     #[test]
     #[should_fail]
+    #[allow(deprecated)]
     fn test_initn_empty() {
         let a: Vec<int> = vec![];
         a.as_slice().initn(2);
@@ -1466,6 +1469,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_unshift() {
         let mut x = vec![1i, 2, 3];
         x.unshift(0);
@@ -2079,6 +2083,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_shift_ref() {
         let mut x: &[int] = [1, 2, 3, 4, 5];
         let h = x.shift_ref();
@@ -2092,6 +2097,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_pop_ref() {
         let mut x: &[int] = [1, 2, 3, 4, 5];
         let h = x.pop_ref();
@@ -2171,6 +2177,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_mut_shift_ref() {
         let mut x: &mut [int] = [1, 2, 3, 4, 5];
         let h = x.mut_shift_ref();
@@ -2184,6 +2191,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_mut_pop_ref() {
         let mut x: &mut [int] = [1, 2, 3, 4, 5];
         let h = x.mut_pop_ref();
@@ -2441,7 +2449,7 @@ mod bench {
         b.iter(|| {
             v.sort();
         });
-        b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+        b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
     }
 
     type BigSortable = (u64,u64,u64,u64);
@@ -2485,6 +2493,6 @@ mod bench {
         b.iter(|| {
             v.sort();
         });
-        b.bytes = (v.len() * mem::size_of_val(v.get(0))) as u64;
+        b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
     }
 }

src/libcore/iter.rs

@@ -2185,7 +2185,7 @@ pub type Iterate<'a, T> = Unfold<'a, T, IterateState<'a, T>>;
 /// Creates a new iterator that produces an infinite sequence of
 /// repeated applications of the given function `f`.
 #[allow(visible_private_types)]
-pub fn iterate<'a, T: Clone>(f: |T|: 'a -> T, seed: T) -> Iterate<'a, T> {
+pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> {
     Unfold::new((f, Some(seed), true), |st| {
         let &(ref mut f, ref mut val, ref mut first) = st;
         if *first {

src/libcore/ops.rs

@@ -55,6 +55,8 @@
  *
  */
 
+use kinds::Sized;
+
 /**
  *
  * The `Drop` trait is used to run some code when a value goes out of scope. This
@@ -700,7 +702,7 @@ pub trait IndexMut<Index,Result> {
  * ```
  */
 #[lang="deref"]
-pub trait Deref<Result> {
+pub trait Deref<Sized? Result> {
     /// The method called to dereference a value
     fn deref<'a>(&'a self) -> &'a Result;
 }
@@ -740,7 +742,7 @@ pub trait Deref<Result> {
  * ```
  */
 #[lang="deref_mut"]
-pub trait DerefMut<Result>: Deref<Result> {
+pub trait DerefMut<Sized? Result>: Deref<Result> {
     /// The method called to mutably dereference a value
     fn deref_mut<'a>(&'a mut self) -> &'a mut Result;
 }

src/libcoretest/any.rs

@@ -51,61 +51,61 @@ fn any_owning() {
 }
 
 #[test]
-fn any_as_ref() {
+fn any_downcast_ref() {
     let a = &5u as &Any;
 
-    match a.as_ref::<uint>() {
+    match a.downcast_ref::<uint>() {
         Some(&5) => {}
         x => fail!("Unexpected value {}", x)
     }
 
-    match a.as_ref::<Test>() {
+    match a.downcast_ref::<Test>() {
         None => {}
         x => fail!("Unexpected value {}", x)
     }
 }
 
 #[test]
-fn any_as_mut() {
+fn any_downcast_mut() {
     let mut a = 5u;
     let mut b = box 7u;
 
     let a_r = &mut a as &mut Any;
     let tmp: &mut uint = &mut *b;
     let b_r = tmp as &mut Any;
 
-    match a_r.as_mut::<uint>() {
+    match a_r.downcast_mut::<uint>() {
         Some(x) => {
             assert_eq!(*x, 5u);
             *x = 612;
         }
         x => fail!("Unexpected value {}", x)
     }
 
-    match b_r.as_mut::<uint>() {
+    match b_r.downcast_mut::<uint>() {
         Some(x) => {
             assert_eq!(*x, 7u);
             *x = 413;
         }
         x => fail!("Unexpected value {}", x)
     }
 
-    match a_r.as_mut::<Test>() {
+    match a_r.downcast_mut::<Test>() {
         None => (),
         x => fail!("Unexpected value {}", x)
     }
 
-    match b_r.as_mut::<Test>() {
+    match b_r.downcast_mut::<Test>() {
         None => (),
         x => fail!("Unexpected value {}", x)
     }
 
-    match a_r.as_mut::<uint>() {
+    match a_r.downcast_mut::<uint>() {
         Some(&612) => {}
         x => fail!("Unexpected value {}", x)
     }
 
-    match b_r.as_mut::<uint>() {
+    match b_r.downcast_mut::<uint>() {
         Some(&413) => {}
         x => fail!("Unexpected value {}", x)
     }
@@ -121,11 +121,11 @@ fn any_fixed_vec() {
 
 
 #[bench]
-fn bench_as_ref(b: &mut Bencher) {
+fn bench_downcast_ref(b: &mut Bencher) {
     b.iter(|| {
         let mut x = 0i;
         let mut y = &mut x as &mut Any;
         test::black_box(&mut y);
-        test::black_box(y.as_ref::<int>() == Some(&0));
+        test::black_box(y.downcast_ref::<int>() == Some(&0));
     });
 }