user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

change how we report err_out_of_scope borrowck errors

Browse source 
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.
This commit is contained in:
Niko Matsakis 2017-07-15 06:52:49 -04:00 • committed by John Kåre Alsaker
parent 188cdf499f
commit 3fdc3fa1ec
17 changed files with 452 additions and 134 deletions
Download patch file Download diff file Expand all files Collapse all files

144
src/test/compile-fail/generator/yield-during-borrow.rs
View file

@ -1,144 +0,0 @@
// 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;
yield();
println!("{}", a);
}; //~ ERROR E0597
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;
yield();
println!("{}", b);
}
}; //~ ERROR E0597
b.resume();
}
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 E0501
b.resume();
}
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 {
yield();
}
}; //~ ERROR E0597
}
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 cannot borrow `x` as immutable
b.resume();
}
fn main() { }

24
src/test/compile-fail/generator/yield-in-args-rev.rs
View file

@ -1,24 +0,0 @@
// 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 `b` does not live long enough
}
fn main() { }

20
src/test/compile-fail/generator/yield-in-args.rs
View file

@ -1,20 +0,0 @@
// 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 `b` does not live long enough
}