---

yaml
---
r: 206335
b: refs/heads/beta
c: df18642
h: refs/heads/master
i:
  206333: 892f0c9
  206331: f3f7711
  206327: 4764851
  206319: d6723ee
  206303: d7e422b
  206271: f4a6f51
  206207: 78dedd1
  206079: b4c5da1
  205823: 0ec64e0
v: v3

Author: steveklabnik

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 5574029b68e4a66864c4eaff8553cc8086117d56
+refs/heads/beta: df18642b1ad80369cefc0cbe626e5b0096654938
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 579e31929feff51dcaf8d444648eff8de735f91a

branches/beta/src/doc/trpl/concurrency.md

@@ -116,7 +116,7 @@ use std::thread;
 fn main() {
     let mut data = vec![1u32, 2, 3];
 
-    for i in 0..3 {
+    for i in 0..2 {
         thread::spawn(move || {
             data[i] += 1;
         });
@@ -154,7 +154,7 @@ use std::sync::Mutex;
 fn main() {
     let mut data = Mutex::new(vec![1u32, 2, 3]);
 
-    for i in 0..3 {
+    for i in 0..2 {
         let data = data.lock().unwrap();
         thread::spawn(move || {
             data[i] += 1;
@@ -196,7 +196,7 @@ use std::thread;
 fn main() {
     let data = Arc::new(Mutex::new(vec![1u32, 2, 3]));
 
-    for i in 0..3 {
+    for i in 0..2 {
         let data = data.clone();
         thread::spawn(move || {
             let mut data = data.lock().unwrap();
@@ -217,7 +217,7 @@ thread more closely:
 # use std::thread;
 # fn main() {
 #     let data = Arc::new(Mutex::new(vec![1u32, 2, 3]));
-#     for i in 0..3 {
+#     for i in 0..2 {
 #         let data = data.clone();
 thread::spawn(move || {
     let mut data = data.lock().unwrap();

branches/beta/src/doc/trpl/patterns.md

@@ -70,8 +70,7 @@ This prints `something else`
 
 # Bindings
 
-If you’re matching multiple things, via a `|` or a `...`, you can bind
-the value to a name with `@`:
+You can bind values to names with `@`:
 
 ```rust
 let x = 1;
@@ -82,7 +81,36 @@ match x {
 }
 ```
 
-This prints `got a range element 1`.
+This prints `got a range element 1`. This is useful when you want to
+do a complicated match of part of a data structure:
+
+```rust
+#[derive(Debug)]
+struct Person {
+    name: Option<String>,
+}
+
+let name = "Steve".to_string();
+let mut x: Option<Person> = Some(Person { name: Some(name) });
+match x {
+    Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a),
+    _ => {}
+}
+```
+
+This prints `Some("Steve")`: We’ve bound the inner `name` to `a`.
+
+If you use `@` with `|`, you need to make sure the name is bound in each part
+of the pattern:
+
+```rust
+let x = 5;
+
+match x {
+    e @ 1 ... 5 | e @ 8 ... 10 => println!("got a range element {}", e),
+    _ => println!("anything"),
+}
+```
 
 # Ignoring variants
 

branches/beta/src/liblog/macros.rs

@@ -136,7 +136,7 @@ macro_rules! info {
 }
 
 /// A convenience macro for logging at the debug log level. This macro can also
-/// be omitted at compile time by passing `-C debug-assertions` to the compiler. If
+/// be omitted at compile time by passing `--cfg ndebug` to the compiler. If
 /// this option is not passed, then debug statements will be compiled.
 ///
 /// # Examples

branches/beta/src/librustc_typeck/check/cast.rs

@@ -170,10 +170,9 @@ pub fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) {
                 demand::coerce(fcx, e.span, t_1, &e);
             }
         }
-    } else if fcx.type_is_fat_ptr(t_e, span) != fcx.type_is_fat_ptr(t_1, span) {
+    } else if fcx.type_is_fat_ptr(t_e, span) && !fcx.type_is_fat_ptr(t_1, span) {
         fcx.type_error_message(span, |actual| {
-            format!("illegal cast; cast to or from fat pointer: `{}` as `{}` \
-                     involving incompatible type.",
+            format!("illegal cast; cast from fat pointer: `{}` as `{}`",
                     actual, fcx.infcx().ty_to_string(t_1))
         }, t_e, None);
     } else if !(t_e_is_scalar && t_1_is_trivial) {

branches/beta/src/test/compile-fail/fat-ptr-cast.rs

@@ -8,24 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Make sure casts between thin pointer <-> fat pointer are illegal.
-
-pub trait Trait {}
-
 fn main() {
     let a: &[i32] = &[1, 2, 3];
     let b: Box<[i32]> = Box::new([1, 2, 3]);
     let p = a as *const [i32];
-    let q = a.as_ptr();
-
-    a as usize; //~ ERROR illegal cast
-    b as usize; //~ ERROR illegal cast
-    p as usize; //~ ERROR illegal cast
-
-    // #22955
-    q as *const [i32]; //~ ERROR illegal cast
 
-    // #21397
-    let t: *mut (Trait + 'static) = 0 as *mut _; //~ ERROR illegal cast
-    let mut fail: *const str = 0 as *const str; //~ ERROR illegal cast
+    a as usize; //~ ERROR cast from fat pointer
+    b as usize; //~ ERROR cast from fat pointer
+    p as usize; //~ ERROR cast from fat pointer
 }

branches/beta/src/test/compile-fail/issue-22034.rs

@@ -11,9 +11,9 @@
 extern crate libc;
 
 fn main() {
-    let ptr: *mut () = 0 as *mut _;
-    let _: &mut Fn() = unsafe {
-        &mut *(ptr as *mut Fn())
-        //~^ ERROR illegal cast
+    let foo: *mut libc::c_void;
+    let cb: &mut Fn() = unsafe {
+        &mut *(foo as *mut Fn())
+        //~^ ERROR use of possibly uninitialized variable: `foo`
     };
 }

branches/beta/src/test/compile-fail/issue-22289.rs

@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    0 as &std::any::Any; //~ ERROR illegal cast
+    0 as &std::any::Any; //~ ERROR non-scalar cast: `i32` as `&core::any::Any`
 }