Update tests and move other tests around

src/test/compile-fail/borrowck-managed-pointer-deref-scope.rs

+// Copyright 2014 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.
+
+// Verify that managed pointers scope is treated like ownoed pointers.
+// regresion test for #11586
+
+#![feature(managed_boxes)]
+
+fn foo<'a>(x: &'a @int) -> &'a int {
+    match x {
+        &ref y => {
+            &**y // Do not expect an error here
+        }
+    }
+}
+
+fn bar() {
+    let a = 3;
+    let mut y = &a;
+    if true {
+        let x = @3;
+        y = &*x; //~ ERROR `*x` does not live long enough
+    }
+}
+
+fn main() {}

src/test/compile-fail/regions-infer-borrow-scope-too-big.rs

+// Copyright 2012 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(managed_boxes)]
+
+struct point {
+    x: int,
+    y: int,
+}
+
+fn x_coord<'r>(p: &'r point) -> &'r int {
+    return &p.x;
+}
+
+fn foo(p: @point) -> &int {
+    let xc = x_coord(p); //~ ERROR `*p` does not live long enough
+    assert_eq!(*xc, 3);
+    return xc;
+}
+
+fn main() {}

src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs

+// Copyright 2012 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(managed_boxes)]
+
+fn borrow<'r, T>(x: &'r T) -> &'r T {x}
+
+fn foo(cond: || -> bool, make_box: || -> @int) {
+    let mut y: &int;
+    loop {
+        let x = make_box();
+
+        // Here we complain because the resulting region
+        // of this borrow is the fn body as a whole.
+        y = borrow(x); //~ ERROR `*x` does not live long enough
+
+        assert_eq!(*x, *y);
+        if cond() { break; }
+    }
+    assert!(*y != 0);
+}
+
+fn main() {}

src/test/run-pass/struct-field-assignability.rs → src/test/compile-fail/struct-field-assignability.rs

@@ -15,6 +15,6 @@ struct Foo<'a> {
 }
 
 pub fn main() {
-    let f = Foo { x: @3 };
+    let f = Foo { x: @3 }; //~ ERROR borrowed value does not live long enough
     assert_eq!(*f.x, 3);
 }

src/test/run-pass/borrowck-preserve-box-in-field.rs

+// ignore-pretty
+
+// Copyright 2012-2014 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.
+
+// exec-env:RUST_POISON_ON_FREE=1
+
+#![feature(managed_boxes)]
+
+fn borrow(x: &int, f: |x: &int|) {
+    let before = *x;
+    f(x);
+    let after = *x;
+    assert_eq!(before, after);
+}
+
+struct F { f: ~int }
+
+pub fn main() {
+    let mut x = @F {f: ~3};
+    borrow(x.f, |b_x| {
+        assert_eq!(*b_x, 3);
+        assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
+        x = @F {f: ~4};
+
+        println!("&*b_x = {:p}", &(*b_x));
+        assert_eq!(*b_x, 3);
+        assert!(&(*x.f) as *int != &(*b_x) as *int);
+    })
+}

src/test/run-pass/borrowck-preserve-box-in-uniq.rs

+// ignore-pretty
+
+// Copyright 2012-2014 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.
+
+// exec-env:RUST_POISON_ON_FREE=1
+
+#![feature(managed_boxes)]
+
+fn borrow(x: &int, f: |x: &int|) {
+    let before = *x;
+    f(x);
+    let after = *x;
+    assert_eq!(before, after);
+}
+
+struct F { f: ~int }
+
+pub fn main() {
+    let mut x = ~@F{f: ~3};
+    borrow(x.f, |b_x| {
+        assert_eq!(*b_x, 3);
+        assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
+        *x = @F{f: ~4};
+
+        println!("&*b_x = {:p}", &(*b_x));
+        assert_eq!(*b_x, 3);
+        assert!(&(*x.f) as *int != &(*b_x) as *int);
+    })
+}

src/test/run-pass/borrowck-preserve-box.rs

+// ignore-pretty
+
+// Copyright 2012-2014 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.
+
+// exec-env:RUST_POISON_ON_FREE=1
+
+#![feature(managed_boxes)]
+
+fn borrow(x: &int, f: |x: &int|) {
+    let before = *x;
+    f(x);
+    let after = *x;
+    assert_eq!(before, after);
+}
+
+pub fn main() {
+    let mut x = @3;
+    borrow(x, |b_x| {
+        assert_eq!(*b_x, 3);
+        assert_eq!(&(*x) as *int, &(*b_x) as *int);
+        x = @22;
+
+        println!("&*b_x = {:p}", &(*b_x));
+        assert_eq!(*b_x, 3);
+        assert!(&(*x) as *int != &(*b_x) as *int);
+    })
+}

src/test/run-pass/borrowck-preserve-cond-box.rs

+// Copyright 2012 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.
+
+// exec-env:RUST_POISON_ON_FREE=1
+
+#![feature(managed_boxes)]
+
+fn testfn(cond: bool) {
+    let mut x = @3;
+    let mut y = @4;
+
+    // borrow x and y
+    let r_x = &*x;
+    let r_y = &*y;
+    let mut r = r_x;
+    let mut exp = 3;
+
+    if cond {
+        r = r_y;
+        exp = 4;
+    }
+
+    println!("*r = {}, exp = {}", *r, exp);
+    assert_eq!(*r, exp);
+
+    x = @5;
+    y = @6;
+
+    println!("*r = {}, exp = {}", *r, exp);
+    assert_eq!(*r, exp);
+    assert_eq!(x, @5);
+    assert_eq!(y, @6);
+}
+
+pub fn main() {
+    testfn(true);
+    testfn(false);
+}

src/test/run-pass/borrowck-preserve-expl-deref.rs

+// ignore-pretty
+
+// Copyright 2012-2014 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.
+
+// exec-env:RUST_POISON_ON_FREE=1
+
+#![feature(managed_boxes)]
+
+fn borrow(x: &int, f: |x: &int|) {
+    let before = *x;
+    f(x);
+    let after = *x;
+    assert_eq!(before, after);
+}
+
+struct F { f: ~int }
+
+pub fn main() {
+    let mut x = @F {f: ~3};
+    borrow((*x).f, |b_x| {
+        assert_eq!(*b_x, 3);
+        assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
+        x = @F {f: ~4};
+
+        println!("&*b_x = {:p}", &(*b_x));
+        assert_eq!(*b_x, 3);
+        assert!(&(*x.f) as *int != &(*b_x) as *int);
+    })
+}