mirror of https://github.com/rust-lang/rust
149 lines
3.4 KiB
Rust
149 lines
3.4 KiB
Rust
// Test that `Box<T>` is treated specially by borrow checking. This is the case
|
|
// because NLL reverted the deicision in rust-lang/rfcs#130.
|
|
|
|
//@ run-pass
|
|
|
|
struct A {
|
|
x: Box<isize>,
|
|
y: isize,
|
|
}
|
|
|
|
struct B {
|
|
x: Box<isize>,
|
|
y: Box<isize>,
|
|
}
|
|
|
|
struct C {
|
|
x: Box<A>,
|
|
y: isize,
|
|
}
|
|
|
|
struct D {
|
|
x: Box<A>,
|
|
y: Box<isize>,
|
|
}
|
|
|
|
fn copy_after_move() {
|
|
let a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
|
|
let _x = a.x;
|
|
let _y = a.y;
|
|
}
|
|
|
|
fn move_after_move() {
|
|
let a: Box<_> = Box::new(B { x: Box::new(0), y: Box::new(1) });
|
|
let _x = a.x;
|
|
let _y = a.y;
|
|
}
|
|
|
|
fn borrow_after_move() {
|
|
let a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
|
|
let _x = a.x;
|
|
let _y = &a.y;
|
|
}
|
|
|
|
fn move_after_borrow() {
|
|
let a: Box<_> = Box::new(B { x: Box::new(0), y: Box::new(1) });
|
|
let _x = &a.x;
|
|
let _y = a.y;
|
|
use_imm(_x);
|
|
}
|
|
fn copy_after_mut_borrow() {
|
|
let mut a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
|
|
let _x = &mut a.x;
|
|
let _y = a.y;
|
|
use_mut(_x);
|
|
}
|
|
fn move_after_mut_borrow() {
|
|
let mut a: Box<_> = Box::new(B { x: Box::new(0), y: Box::new(1) });
|
|
let _x = &mut a.x;
|
|
let _y = a.y;
|
|
use_mut(_x);
|
|
}
|
|
fn borrow_after_mut_borrow() {
|
|
let mut a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
|
|
let _x = &mut a.x;
|
|
let _y = &a.y;
|
|
use_mut(_x);
|
|
}
|
|
fn mut_borrow_after_borrow() {
|
|
let mut a: Box<_> = Box::new(A { x: Box::new(0), y: 1 });
|
|
let _x = &a.x;
|
|
let _y = &mut a.y;
|
|
use_imm(_x);
|
|
}
|
|
fn copy_after_move_nested() {
|
|
let a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
|
|
let _x = a.x.x;
|
|
let _y = a.y;
|
|
}
|
|
|
|
fn move_after_move_nested() {
|
|
let a: Box<_> = Box::new(D { x: Box::new(A { x: Box::new(0), y: 1 }), y: Box::new(2) });
|
|
let _x = a.x.x;
|
|
let _y = a.y;
|
|
}
|
|
|
|
fn borrow_after_move_nested() {
|
|
let a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
|
|
let _x = a.x.x;
|
|
let _y = &a.y;
|
|
}
|
|
|
|
fn move_after_borrow_nested() {
|
|
let a: Box<_> = Box::new(D { x: Box::new(A { x: Box::new(0), y: 1 }), y: Box::new(2) });
|
|
let _x = &a.x.x;
|
|
let _y = a.y;
|
|
use_imm(_x);
|
|
}
|
|
fn copy_after_mut_borrow_nested() {
|
|
let mut a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
|
|
let _x = &mut a.x.x;
|
|
let _y = a.y;
|
|
use_mut(_x);
|
|
}
|
|
fn move_after_mut_borrow_nested() {
|
|
let mut a: Box<_> = Box::new(D { x: Box::new(A { x: Box::new(0), y: 1 }), y: Box::new(2) });
|
|
let _x = &mut a.x.x;
|
|
let _y = a.y;
|
|
use_mut(_x);
|
|
}
|
|
fn borrow_after_mut_borrow_nested() {
|
|
let mut a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
|
|
let _x = &mut a.x.x;
|
|
let _y = &a.y;
|
|
use_mut(_x);
|
|
}
|
|
fn mut_borrow_after_borrow_nested() {
|
|
let mut a: Box<_> = Box::new(C { x: Box::new(A { x: Box::new(0), y: 1 }), y: 2 });
|
|
let _x = &a.x.x;
|
|
let _y = &mut a.y;
|
|
use_imm(_x);
|
|
}
|
|
|
|
fn main() {
|
|
copy_after_move();
|
|
move_after_move();
|
|
borrow_after_move();
|
|
|
|
move_after_borrow();
|
|
|
|
copy_after_mut_borrow();
|
|
move_after_mut_borrow();
|
|
borrow_after_mut_borrow();
|
|
mut_borrow_after_borrow();
|
|
|
|
copy_after_move_nested();
|
|
move_after_move_nested();
|
|
borrow_after_move_nested();
|
|
|
|
move_after_borrow_nested();
|
|
|
|
copy_after_mut_borrow_nested();
|
|
move_after_mut_borrow_nested();
|
|
borrow_after_mut_borrow_nested();
|
|
mut_borrow_after_borrow_nested();
|
|
}
|
|
|
|
fn use_mut<T>(_: &mut T) { }
|
|
fn use_imm<T>(_: &T) { }
|