1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
|
fn borrow(_v: &isize) {}
fn borrow_mut(_v: &mut isize) {}
fn cond() -> bool { panic!() }
fn produce<T>() -> T { panic!(); }
fn inc(v: &mut Box<isize>) {
*v = Box::new(**v + 1);
}
fn loop_overarching_alias_mut() {
// In this instance, the borrow ends on the line before the loop
let mut v: Box<_> = Box::new(3);
let mut x = &mut v;
**x += 1;
loop {
borrow(&*v); // OK
}
}
fn block_overarching_alias_mut() {
// In this instance, the borrow encompasses the entire closure call.
let mut v: Box<_> = Box::new(3);
let mut x = &mut v;
for _ in 0..3 {
borrow(&*v); //~ ERROR cannot borrow
}
*x = Box::new(5);
}
fn loop_aliased_mut() {
// In this instance, the borrow ends right after each assignment to _x
let mut v: Box<_> = Box::new(3);
let mut w: Box<_> = Box::new(4);
let mut _x = &w;
loop {
borrow_mut(&mut *v); // OK
_x = &v;
}
}
fn while_aliased_mut() {
// In this instance, the borrow ends right after each assignment to _x
let mut v: Box<_> = Box::new(3);
let mut w: Box<_> = Box::new(4);
let mut _x = &w;
while cond() {
borrow_mut(&mut *v); // OK
_x = &v;
}
}
fn loop_aliased_mut_break() {
// In this instance, the borrow ends right after each assignment to _x
let mut v: Box<_> = Box::new(3);
let mut w: Box<_> = Box::new(4);
let mut _x = &w;
loop {
borrow_mut(&mut *v);
_x = &v;
break;
}
borrow_mut(&mut *v); // OK
}
fn while_aliased_mut_break() {
// In this instance, the borrow ends right after each assignment to _x
let mut v: Box<_> = Box::new(3);
let mut w: Box<_> = Box::new(4);
let mut _x = &w;
while cond() {
borrow_mut(&mut *v);
_x = &v;
break;
}
borrow_mut(&mut *v); // OK
}
fn while_aliased_mut_cond(cond: bool, cond2: bool) {
let mut v: Box<_> = Box::new(3);
let mut w: Box<_> = Box::new(4);
let mut x = &mut w;
while cond {
**x += 1;
borrow(&*v); //~ ERROR cannot borrow
if cond2 {
x = &mut v; // OK
}
}
}
fn loop_break_pops_scopes<'r, F>(_v: &'r mut [usize], mut f: F) where
F: FnMut(&'r mut usize) -> bool,
{
// Here we check that when you break out of an inner loop, the
// borrows that go out of scope as you exit the inner loop are
// removed from the bitset.
while cond() {
while cond() {
// this borrow is limited to the scope of `r`...
let r: &'r mut usize = produce();
if !f(&mut *r) {
break; // ...so it is not live as exit the `while` loop here
}
}
}
}
fn loop_loop_pops_scopes<'r, F>(_v: &'r mut [usize], mut f: F)
where F: FnMut(&'r mut usize) -> bool
{
// Similar to `loop_break_pops_scopes` but for the `loop` keyword
while cond() {
while cond() {
// this borrow is limited to the scope of `r`...
let r: &'r mut usize = produce();
if !f(&mut *r) {
continue; // ...so it is not live as exit (and re-enter) the `while` loop here
}
}
}
}
fn main() {}
|