update test cases to reflect new messages

Author: nikomatsakis

src/test/compile-fail/array-not-vector.rs

@@ -11,16 +11,14 @@
 fn main() {
     let _x: i32 = [1, 2, 3];
     //~^ ERROR mismatched types
-    //~| expected `i32`
-    //~| found `[_; 3]`
-    //~| expected i32
-    //~| found array of 3 elements
+    //~| expected type `i32`
+    //~| found type `[_; 3]`
+    //~| expected i32, found array of 3 elements
 
     let x: &[i32] = &[1, 2, 3];
     let _y: &i32 = x;
     //~^ ERROR mismatched types
-    //~| expected `&i32`
-    //~| found `&[i32]`
-    //~| expected i32
-    //~| found slice
+    //~| expected type `&i32`
+    //~| found type `&[i32]`
+    //~| expected i32, found slice
 }

src/test/compile-fail/associated-types-eq-3.rs

@@ -32,10 +32,9 @@ fn foo1<I: Foo<A=Bar>>(x: I) {
 fn foo2<I: Foo>(x: I) {
     let _: Bar = x.boo();
     //~^ ERROR mismatched types
-    //~| expected `Bar`
-    //~| found `<I as Foo>::A`
-    //~| expected struct `Bar`
-    //~| found associated type
+    //~| expected type `Bar`
+    //~| found type `<I as Foo>::A`
+    //~| expected struct `Bar`, found associated type
 }
 
 

src/test/compile-fail/associated-types-path-2.rs

@@ -28,8 +28,7 @@ pub fn f2<T: Foo>(a: T) -> T::A {
 pub fn f1_int_int() {
     f1(2i32, 4i32);
     //~^ ERROR mismatched types
-    //~| expected `u32`
-    //~| found `i32`
+    //~| expected u32, found i32
 }
 
 pub fn f1_int_uint() {
@@ -49,8 +48,7 @@ pub fn f1_uint_int() {
 pub fn f2_int() {
     let _: i32 = f2(2i32);
     //~^ ERROR mismatched types
-    //~| expected `i32`
-    //~| found `u32`
+    //~| expected i32, found u32
 }
 
 pub fn main() { }

src/test/compile-fail/augmented-assignments.rs

@@ -21,8 +21,10 @@ impl AddAssign for Int {
 fn main() {
     let mut x = Int(1);
     x   //~ error: use of moved value: `x`
+    //~^ value used here after move
+    //~| note: move occurs because `x` has type `Int`
     +=
-    x;  //~ note: `x` moved here because it has type `Int`, which is non-copyable
+    x;  //~ value moved here
 
     let y = Int(2);
     y   //~ error: cannot borrow immutable local variable `y` as mutable

src/test/compile-fail/bad-const-type.rs

@@ -10,8 +10,7 @@
 
 static i: String = 10;
 //~^ ERROR mismatched types
-//~| expected `std::string::String`
-//~| found `_`
-//~| expected struct `std::string::String`
-//~| found integral variable
+//~| expected type `std::string::String`
+//~| found type `_`
+//~| expected struct `std::string::String`, found integral variable
 fn main() { println!("{}", i); }

src/test/compile-fail/bad-main.rs

@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn main(x: isize) { } //~ ERROR: main function expects type
+fn main(x: isize) { } //~ ERROR: main function has wrong type

src/test/compile-fail/binop-move-semantics.rs

@@ -62,6 +62,7 @@ fn mut_plus_immut() {
     &mut f
     +
     &f;  //~ ERROR: cannot borrow `f` as immutable because it is also borrowed as mutable
+    //~^ cannot borrow `f` as immutable because it is also borrowed as mutable
 }
 
 fn immut_plus_mut() {
@@ -70,6 +71,7 @@ fn immut_plus_mut() {
     &f
     +
     &mut f;  //~ ERROR: cannot borrow `f` as mutable because it is also borrowed as immutable
+    //~^ cannot borrow `f` as mutable because it is also borrowed as immutable
 }
 
 fn main() {}

src/test/compile-fail/block-must-not-have-result-while.rs

@@ -11,9 +11,8 @@
 fn main() {
     while true {
         true //~  ERROR mismatched types
-             //~| expected `()`
-             //~| found `bool`
-             //~| expected ()
-             //~| found bool
+             //~| expected type `()`
+             //~| found type `bool`
+             //~| expected (), found bool
     }
 }

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

@@ -33,22 +33,28 @@ struct D {
 fn copy_after_move() {
     let a: Box<_> = box A { x: box 0, y: 1 };
     let _x = a.x;
+    //~^ value moved here
     let _y = a.y; //~ ERROR use of moved
-    //~^^ NOTE `a` moved here (through moving `a.x`)
+    //~^ move occurs because `a.x` has type `Box<isize>`
+    //~| value used here after move
 }
 
 fn move_after_move() {
     let a: Box<_> = box B { x: box 0, y: box 1 };
     let _x = a.x;
+    //~^ value moved here
     let _y = a.y; //~ ERROR use of moved
-    //~^^ NOTE `a` moved here (through moving `a.x`)
+    //~^ move occurs because `a.x` has type `Box<isize>`
+    //~| value used here after move
 }
 
 fn borrow_after_move() {
     let a: Box<_> = box A { x: box 0, y: 1 };
     let _x = a.x;
+    //~^ value moved here
     let _y = &a.y; //~ ERROR use of moved
-    //~^^ NOTE `a` moved here (through moving `a.x`)
+    //~^ move occurs because `a.x` has type `Box<isize>`
+    //~| value used here after move
 }
 
 fn move_after_borrow() {
@@ -75,44 +81,52 @@ fn move_after_mut_borrow() {
 fn borrow_after_mut_borrow() {
     let mut a: Box<_> = box A { x: box 0, y: 1 };
     let _x = &mut a.x;
-    //~^ NOTE previous borrow of `a` occurs here (through borrowing `a.x`);
+    //~^ NOTE mutable borrow occurs here (via `a.x`)
     let _y = &a.y; //~ ERROR cannot borrow
+    //~^ immutable borrow occurs here (via `a.y`)
 }
-//~^ NOTE previous borrow ends here
+//~^ NOTE mutable borrow ends here
 
 fn mut_borrow_after_borrow() {
     let mut a: Box<_> = box A { x: box 0, y: 1 };
     let _x = &a.x;
-    //~^ NOTE previous borrow of `a` occurs here (through borrowing `a.x`)
+    //~^ NOTE immutable borrow occurs here (via `a.x`)
     let _y = &mut a.y; //~ ERROR cannot borrow
+    //~^ mutable borrow occurs here (via `a.y`)
 }
-//~^ NOTE previous borrow ends here
+//~^ NOTE immutable borrow ends here
 
 fn copy_after_move_nested() {
     let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = a.x.x;
-    //~^ NOTE `a.x.x` moved here because it has type `Box<isize>`, which is moved by default
+    //~^ value moved here
     let _y = a.y; //~ ERROR use of collaterally moved
+    //~^ NOTE move occurs because `a.x.x` has type `Box<isize>`
+    //~| value used here after move
 }
 
 fn move_after_move_nested() {
     let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
     let _x = a.x.x;
-    //~^ NOTE `a.x.x` moved here because it has type `Box<isize>`, which is moved by default
+    //~^ value moved here
     let _y = a.y; //~ ERROR use of collaterally moved
+    //~^ NOTE move occurs because `a.x.x` has type `Box<isize>`
+    //~| value used here after move
 }
 
 fn borrow_after_move_nested() {
     let a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = a.x.x;
-    //~^ NOTE `a.x.x` moved here because it has type `Box<isize>`, which is moved by default
+    //~^ value moved here
     let _y = &a.y; //~ ERROR use of collaterally moved
+    //~^ NOTE move occurs because `a.x.x` has type `Box<isize>`
+    //~| value used here after move
 }
 
 fn move_after_borrow_nested() {
     let a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 };
     let _x = &a.x.x;
-    //~^ NOTE borrow of `a.x.x` occurs here
+    //~^ borrow of `a.x.x` occurs here
     let _y = a.y; //~ ERROR cannot move
 }
 
@@ -133,18 +147,20 @@ fn move_after_mut_borrow_nested() {
 fn borrow_after_mut_borrow_nested() {
     let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = &mut a.x.x;
-    //~^ NOTE previous borrow of `a.x.x` occurs here; the mutable borrow prevents
+    //~^ mutable borrow occurs here
     let _y = &a.y; //~ ERROR cannot borrow
+    //~^ immutable borrow occurs here
 }
-//~^ NOTE previous borrow ends here
+//~^ NOTE mutable borrow ends here
 
 fn mut_borrow_after_borrow_nested() {
     let mut a: Box<_> = box C { x: box A { x: box 0, y: 1 }, y: 2 };
     let _x = &a.x.x;
-    //~^ NOTE previous borrow of `a.x.x` occurs here; the immutable borrow prevents
+    //~^ immutable borrow occurs here
     let _y = &mut a.y; //~ ERROR cannot borrow
+    //~^ mutable borrow occurs here
 }
-//~^ NOTE previous borrow ends here
+//~^ NOTE immutable borrow ends here
 
 fn main() {
     copy_after_move();

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

@@ -24,7 +24,7 @@ fn a(x: &isize) {
     //~^ ERROR cannot borrow
     let c2 = || set(&mut *x);
     //~^ ERROR cannot borrow
-    //~| ERROR closure requires unique access
+    //~| ERROR two closures require unique access to `x` at the same time
 }
 
 fn main() {