change how we report err_out_of_scope borrowck errors

Also, remove the explicit code detecting borrows over a yield.  It
turns out not to be necessary -- any such borrow winds up with a
lifetime that is part of the generator type, and therefore which will
outlive the generator expression itself, which yields an
`err_out_of_scope`. So instead we intercept those errors and display
them in a nicer way.

src/test/ui/generator/ref-escapes-but-not-over-yield.rs

@@ -0,0 +1,28 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(generators, generator_trait)]
+
+use std::ops::{State, Generator};
+use std::cell::Cell;
+
+fn foo(x: &i32) {
+    // In this case, a reference to `b` escapes the generator, but not
+    // because of a yield. We see that there is no yield in the scope of
+    // `b` and give the more generic error message.
+    let mut a = &3;
+    let mut b = move || {
+        yield();
+        let b = 5;
+        a = &b; //~ ERROR
+    };
+}
+
+fn main() { }

src/test/ui/generator/ref-escapes-but-not-over-yield.stderr

@@ -0,0 +1,12 @@
+error[E0597]: `b` does not live long enough
+  --> $DIR/ref-escapes-but-not-over-yield.rs:25:5
+   |
+24 |         a = &b; //~ ERROR
+   |              - borrow occurs here
+25 |     };
+   |     ^ `b` dropped here while still borrowed
+26 | }
+   | - borrowed value needs to live until here
+
+error: aborting due to previous error
+

src/test/ui/generator/yield-in-args-rev.rs

@@ -0,0 +1,24 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(generators)]
+
+fn foo(_a: (), _b: &bool) {}
+
+// Some examples that probably *could* be accepted, but which we reject for now.
+
+fn bar() {
+	|| {
+		let b = true;
+		foo(yield, &b); //~ ERROR
+	};
+}
+
+fn main() { }

src/test/ui/generator/yield-in-args-rev.stderr

@@ -0,0 +1,10 @@
+error[E0624]: borrow may still be in use when generator yields
+  --> $DIR/yield-in-args-rev.rs:20:15
+   |
+20 | \t\tfoo(yield, &b); //~ ERROR
+   | \t\t    -----   ^
+   | \t\t    |
+   | \t\t    possible yield occurs here
+
+error: aborting due to previous error
+

src/test/ui/generator/yield-in-args.rs

@@ -0,0 +1,20 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(generators)]
+
+fn foo(_b: &bool, _a: ()) {}
+
+fn main() {
+	|| {
+		let b = true;
+		foo(&b, yield); //~ ERROR
+	};
+}

src/test/ui/generator/yield-in-args.stderr

@@ -0,0 +1,8 @@
+error[E0624]: borrow may still be in use when generator yields
+  --> $DIR/yield-in-args.rs:18:8
+   |
+18 | \t\tfoo(&b, yield); //~ ERROR
+   | \t\t     ^  ----- possible yield occurs here
+
+error: aborting due to previous error
+

src/test/ui/generator/yield-while-iterating.rs

@@ -0,0 +1,84 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(generators, generator_trait)]
+
+use std::ops::{State, Generator};
+use std::cell::Cell;
+
+fn yield_during_iter_owned_data(x: Vec<i32>) {
+    // The generator owns `x`, so we error out when yielding with a
+    // reference to it.  This winds up becoming a rather confusing
+    // regionck error -- in particular, we would freeze with the
+    // reference in scope, and it doesn't live long enough.
+    let _b = move || {
+        for p in &x { //~ ERROR
+            yield();
+        }
+    };
+}
+
+fn yield_during_iter_borrowed_slice(x: &[i32]) {
+    let _b = move || {
+        for p in x {
+            yield();
+        }
+    };
+}
+
+fn yield_during_iter_borrowed_slice_2() {
+    let mut x = vec![22_i32];
+    let _b = || {
+        for p in &x {
+            yield();
+        }
+    };
+    println!("{:?}", x);
+}
+
+fn yield_during_iter_borrowed_slice_3() {
+    // OK to take a mutable ref to `x` and yield
+    // up pointers from it:
+    let mut x = vec![22_i32];
+    let mut b = || {
+        for p in &mut x {
+            yield p;
+        }
+    };
+    b.resume();
+}
+
+fn yield_during_iter_borrowed_slice_4() {
+    // ...but not OK to do that while reading
+    // from `x` too
+    let mut x = vec![22_i32];
+    let mut b = || {
+        for p in &mut x {
+            yield p;
+        }
+    };
+    println!("{}", x[0]); //~ ERROR
+    b.resume();
+}
+
+fn yield_during_range_iter() {
+    // Should be OK.
+    let mut b = || {
+        let v = vec![1,2,3];
+        let len = v.len();
+        for i in 0..len {
+            let x = v[i];
+            yield x;
+        }
+    };
+    b.resume();
+}
+
+fn main() { }

src/test/ui/generator/yield-while-iterating.stderr

@@ -0,0 +1,24 @@
+error[E0624]: borrow may still be in use when generator yields
+  --> $DIR/yield-while-iterating.rs:22:19
+   |
+22 |         for p in &x { //~ ERROR
+   |                   ^
+23 |             yield();
+   |             ------- possible yield occurs here
+
+error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
+  --> $DIR/yield-while-iterating.rs:67:20
+   |
+62 |     let mut b = || {
+   |                 -- mutable borrow occurs here
+63 |         for p in &mut x {
+   |                       - previous borrow occurs due to use of `x` in closure
+...
+67 |     println!("{}", x[0]); //~ ERROR
+   |                    ^ immutable borrow occurs here
+68 |     b.resume();
+69 | }
+   | - mutable borrow ends here
+
+error: aborting due to 2 previous errors
+

src/test/ui/generator/yield-while-local-borrowed.rs

@@ -0,0 +1,56 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(generators, generator_trait)]
+
+use std::ops::{State, Generator};
+use std::cell::Cell;
+
+fn borrow_local_inline() {
+    // Not OK to yield with a borrow of a temporary.
+    //
+    // (This error occurs because the region shows up in the type of
+    // `b` and gets extended by region inference.)
+    let mut b = move || {
+        let a = &3; //~ ERROR
+        yield();
+        println!("{}", a);
+    };
+    b.resume();
+}
+
+fn borrow_local_inline_done() {
+    // No error here -- `a` is not in scope at the point of `yield`.
+    let mut b = move || {
+        {
+            let a = &3;
+        }
+        yield();
+    };
+    b.resume();
+}
+
+fn borrow_local() {
+    // Not OK to yield with a borrow of a temporary.
+    //
+    // (This error occurs because the region shows up in the type of
+    // `b` and gets extended by region inference.)
+    let mut b = move || {
+        let a = 3;
+        {
+            let b = &a; //~ ERROR
+            yield();
+            println!("{}", b);
+        }
+    };
+    b.resume();
+}
+
+fn main() { }

src/test/ui/generator/yield-while-local-borrowed.stderr

@@ -0,0 +1,18 @@
+error[E0624]: borrow may still be in use when generator yields
+  --> $DIR/yield-while-local-borrowed.rs:22:18
+   |
+22 |         let a = &3; //~ ERROR
+   |                  ^
+23 |         yield();
+   |         ------- possible yield occurs here
+
+error[E0624]: borrow may still be in use when generator yields
+  --> $DIR/yield-while-local-borrowed.rs:48:22
+   |
+48 |             let b = &a; //~ ERROR
+   |                      ^
+49 |             yield();
+   |             ------- possible yield occurs here
+
+error: aborting due to 2 previous errors
+

src/test/ui/generator/yield-while-ref-reborrowed.rs

@@ -0,0 +1,49 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(generators, generator_trait)]
+
+use std::ops::{State, Generator};
+use std::cell::Cell;
+
+fn reborrow_shared_ref(x: &i32) {
+    // This is OK -- we have a borrow live over the yield, but it's of
+    // data that outlives the generator.
+    let mut b = move || {
+        let a = &*x;
+        yield();
+        println!("{}", a);
+    };
+    b.resume();
+}
+
+fn reborrow_mutable_ref(x: &mut i32) {
+    // This is OK -- we have a borrow live over the yield, but it's of
+    // data that outlives the generator.
+    let mut b = move || {
+        let a = &mut *x;
+        yield();
+        println!("{}", a);
+    };
+    b.resume();
+}
+
+fn reborrow_mutable_ref_2(x: &mut i32) {
+    // ...but not OK to go on using `x`.
+    let mut b = || {
+        let a = &mut *x;
+        yield();
+        println!("{}", a);
+    };
+    println!("{}", x); //~ ERROR
+    b.resume();
+}
+
+fn main() { }

src/test/ui/generator/yield-while-ref-reborrowed.stderr

@@ -0,0 +1,16 @@
+error[E0501]: cannot borrow `x` as immutable because previous closure requires unique access
+  --> $DIR/yield-while-ref-reborrowed.rs:45:20
+   |
+40 |     let mut b = || {
+   |                 -- closure construction occurs here
+41 |         let a = &mut *x;
+   |                       - previous borrow occurs due to use of `x` in closure
+...
+45 |     println!("{}", x); //~ ERROR
+   |                    ^ borrow occurs here
+46 |     b.resume();
+47 | }
+   | - borrow from closure ends here
+
+error: aborting due to previous error
+