Update compile-fail tests for new by-value closure semantics.

Author: pcwalton

src/test/compile-fail/borrowck-assign-comp-idx.rs

@@ -26,17 +26,6 @@ fn a() {
 
 fn borrow(_x: &[int], _f: ||) {}
 
-fn b() {
-    // here we alias the mutable vector into an imm slice and try to
-    // modify the original:
-
-    let mut p = vec!(1);
-
-    borrow(
-        p.as_slice(),
-        || *p.get_mut(0) = 5); //~ ERROR cannot borrow `p` as mutable
-}
-
 fn c() {
     // Legal because the scope of the borrow does not include the
     // modification:

src/test/compile-fail/borrowck-autoref-3261.rs

@@ -21,11 +21,12 @@ impl X {
 
 fn main() {
     let mut x = X(Right(main));
-    (&mut x).with(
-        |opt| { //~ ERROR cannot borrow `x` as mutable more than once at a time
+    let x_ptr = &mut x;
+    x_ptr.with(
+        |opt| { //~ ERROR closure requires unique access
             match opt {
                 &Right(ref f) => {
-                    x = X(Left((0,0)));
+                    *x_ptr = X(Left((0,0)));    //~ ERROR cannot move `x_ptr`
                     (*f)()
                 },
                 _ => fail!()

src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs

@@ -19,8 +19,8 @@ struct Test<'a> {
 
 fn call(f: |Fn|) {
     f(|| {
-    //~^ ERROR: closure requires unique access to `f` but it is already borrowed
         f(|| {})
+        //~^ ERROR: cannot move `f` into closure
     });
 }
 
@@ -56,8 +56,9 @@ fn test6() {
 fn test7() {
     fn foo(_: |g: |int|, b: int|) {}
     let f = |g: |int|, b: int| {};
-    f(|a| { //~ ERROR: cannot borrow `f` as immutable because previous closure
-        foo(f); //~ ERROR: cannot move out of captured outer variable
+    f(|a| {
+        foo(f); //~ ERROR: cannot move `f`
+        //~^ ERROR cannot move out of captured outer variable
     }, 3);
 }
 

src/test/compile-fail/borrowck-closures-mut-and-imm.rs

@@ -24,26 +24,8 @@ fn set(x: &mut int) -> int {
 
 fn a(x: &mut int) {
     let c1 = || get(x);
-    let c2 = || get(x);
-}
-
-fn b(x: &mut int) {
-    let c1 = || get(x);
-    let c2 = || set(x); //~ ERROR closure requires unique access to `x`
-}
-
-fn c(x: &mut int) {
-    let c1 = || get(x);
-    let c2 = || { get(x); set(x); }; //~ ERROR closure requires unique access to `x`
-}
-
-fn d(x: &mut int) {
-    let c1 = || set(x);
-    let c2 = || set(x); //~ ERROR closure requires unique access to `x`
-}
-
-fn e(x: &mut int) {
-    let c1: || = || x = fail!(); //~ ERROR closure cannot assign to immutable argument `x`
+    let c2 = || get(x); //~ ERROR closure requires unique access to `*x`
+    //~^ ERROR cannot move `x`
 }
 
 fn main() {

src/test/compile-fail/borrowck-closures-mut-of-imm.rs

@@ -25,8 +25,11 @@ impl Drop for Foo {
 
 fn main() {
   let mut ptr = box Foo { x: 0 };
+  let ptr_ref = &mut ptr;
   let test = |foo: &Foo| {
-    ptr = box Foo { x: ptr.x + 1 };
+    *ptr_ref = box Foo {
+        x: ptr_ref.x + 1,
+    };
   };
   test(ptr); //~ ERROR cannot borrow `*ptr`
 }

src/test/compile-fail/borrowck-closures-two-mut.rs

@@ -25,8 +25,8 @@ impl Foo {
 
 fn bar(f: &mut Foo) {
   f.foo(
-        |a| { //~ ERROR closure requires unique access to `f`
-            f.n.insert(*a);
+        |a| { //~ ERROR closure requires unique access to `*f`
+            f.n.insert(*a); //~ ERROR cannot move `f`
         })
 }
 

src/test/compile-fail/borrowck-closures-unique.rs

@@ -14,10 +14,11 @@ fn borrow(v: &int, f: |x: &int|) {
 
 fn box_imm() {
     let mut v = box 3;
-    borrow(v,
-           |w| { //~ ERROR cannot borrow `v` as mutable
-            v = box 4;
-            assert_eq!(*v, 3);
+    let v_ptr = &mut v;
+    borrow(*v_ptr,
+           |w| { //~ ERROR closure requires unique access to `*v_ptr`
+            *v_ptr = box 4; //~ ERROR cannot move `v_ptr`
+            assert_eq!(**v_ptr, 3);
             assert_eq!(*w, 4);
         })
 }

src/test/compile-fail/borrowck-closures-use-after-free.rs

@@ -32,8 +32,9 @@ fn a() {
     p.impurem();
 
     // But in this case we do not honor the loan:
-    p.blockm(|| { //~ ERROR cannot borrow `p` as mutable
-        p.x = 10;
+    p.blockm(|| {
+        p.x = 10; //~ ERROR cannot move `p` into closure
+        //~^ ERROR cannot assign to immutable field
     })
 }
 

src/test/compile-fail/borrowck-insert-during-each.rs

@@ -25,8 +25,9 @@ fn has_mut_vec_but_tries_to_change_it() {
     let mut v = vec!(1, 2, 3);
     takes_imm_elt(
         v.get(0),
-        || { //~ ERROR cannot borrow `v` as mutable
-            *v.get_mut(1) = 4;
+        || {
+            *v.get_mut(1) = 4;  //~ ERROR cannot move `v`
+            //~^ ERROR cannot borrow
         })
 }
 

src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs

@@ -25,11 +25,11 @@ struct F { f: Box<int> }
 pub fn main() {
     let mut x = @F {f: box 3};
     borrow(x.f, |b_x| {
-    //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable
         assert_eq!(*b_x, 3);
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
-        //~^ NOTE borrow occurs due to use of `x` in closure
+        //~^ ERROR cannot move `x` into closure
         x = @F {f: box 4};
+        //~^ ERROR cannot assign
 
         println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);

src/test/compile-fail/borrowck-loan-rcvr.rs

@@ -25,11 +25,11 @@ struct F { f: Box<int> }
 pub fn main() {
     let mut x = box @F{f: box 3};
     borrow(x.f, |b_x| {
-    //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable
         assert_eq!(*b_x, 3);
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
-        //~^ NOTE  borrow occurs due to use of `x` in closure
+        //~^ ERROR cannot move `x` into closure
         *x = @F{f: box 4};
+        //~^ ERROR cannot assign to immutable dereference
 
         println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);

src/test/compile-fail/borrowck-loan-vec-content.rs

@@ -22,11 +22,11 @@ fn borrow(x: &int, f: |x: &int|) {
 pub fn main() {
     let mut x = @3;
     borrow(x, |b_x| {
-    //~^ ERROR cannot borrow `x` as mutable because `*x` is also borrowed as immutable
         assert_eq!(*b_x, 3);
         assert_eq!(&(*x) as *int, &(*b_x) as *int);
-        //~^ NOTE borrow occurs due to use of `x` in closure
+        //~^ ERROR cannot move `x` into closure
         x = @22;
+        //~^ ERROR cannot assign to immutable captured outer variable
 
         println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);

src/test/compile-fail/borrowck-preserve-box-in-field.rs

@@ -25,11 +25,11 @@ struct F { f: Box<int> }
 pub fn main() {
     let mut x = @F {f: box 3};
     borrow((*x).f, |b_x| {
-    //~^ ERROR cannot borrow `x` as mutable because `*x.f` is also borrowed as immutable
         assert_eq!(*b_x, 3);
         assert_eq!(&(*x.f) as *int, &(*b_x) as *int);
-        //~^ NOTE borrow occurs due to use of `x` in closure
+        //~^ ERROR cannot move `x` into closure
         x = @F {f: box 4};
+        //~^ ERROR cannot assign to immutable captured outer variable
 
         println!("&*b_x = {:p}", &(*b_x));
         assert_eq!(*b_x, 3);

src/test/compile-fail/borrowck-preserve-box-in-uniq.rs

@@ -23,9 +23,10 @@ fn main() {
     let test = |foo: &Foo| {
         println!("access {}", foo.x);
         ptr = box Foo { x: ptr.x + 1 };
+        //~^ ERROR cannot assign to immutable captured outer variable
         println!("access {}", foo.x);
     };
     test(ptr);
-    //~^ ERROR: cannot borrow `*ptr` as immutable
+    //~^ ERROR use of moved value
 }
 

src/test/compile-fail/borrowck-preserve-box.rs

@@ -11,7 +11,8 @@
 fn main() {
     let mut v = vec!(1);
     let f = || v.push(2);
-    let _w = v; //~ ERROR: cannot move out of `v`
+    //~^ ERROR cannot borrow immutable captured outer variable
+    let _w = v; //~ ERROR: use of moved value
 
     f();
 }