Change:
fn copy_after_move() { let a: Box<_> = box A { x: box 0, y: 1 }; let _x = a.x; <del> //~^ value moved here let _y = a.y; //~ ERROR use of moved //~^ move occurs because `a.x` has type `std::boxed::Box<isize>` //~| value used here after move </del> <ins> //[ast]~^ value moved here let _y = a.y; //[ast]~ ERROR use of moved //[ast]~^ move occurs because `a.x` has type `std::boxed::Box<isize>` //[ast]~| value used here after move </ins> } fn move_after_move() { let a: Box<_> = box B { x: box 0, y: box 1 }; let _x = a.x; <del> //~^ value moved here let _y = a.y; //~ ERROR use of moved //~^ move occurs because `a.x` has type `std::boxed::Box<isize>` //~| value used here after move </del> <ins> //[ast]~^ value moved here let _y = a.y; //[ast]~ ERROR use of moved //[ast]~^ move occurs because `a.x` has type `std::boxed::Box<isize>` //[ast]~| value used here after move </ins> } fn borrow_after_move() { let a: Box<_> = box A { x: box 0, y: 1 }; let _x = a.x; <del> //~^ value moved here let _y = &a.y; //~ ERROR use of moved //~^ move occurs because `a.x` has type `std::boxed::Box<isize>` //~| value used here after move </del> <ins> //[ast]~^ value moved here let _y = &a.y; //[ast]~ ERROR use of moved //[ast]~^ move occurs because `a.x` has type `std::boxed::Box<isize>` //[ast]~| value used here after move </ins> } fn move_after_borrow() { let a: Box<_> = box B { x: box 0, y: box 1 }; let _x = &a.x; let _y = a.y; <del> //~^ ERROR cannot move //~| move out of </del> <ins> //[ast]~^ ERROR cannot move //[ast]~| move out of use_imm(_x); </ins> } fn copy_after_mut_borrow() { let mut a: Box<_> = box A { x: box 0, y: 1 }; let _x = &mut a.x; <del> let _y = a.y; //~ ERROR cannot use </del> <ins> let _y = a.y; //[ast]~ ERROR cannot use use_mut(_x); </ins> } fn move_after_mut_borrow() { let mut a: Box<_> = box B { x: box 0, y: box 1 }; let _x = &mut a.x; let _y = a.y; <del> //~^ ERROR cannot move //~| move out of </del> <ins> //[ast]~^ ERROR cannot move //[ast]~| move out of use_mut(_x); </ins> } fn borrow_after_mut_borrow() { let mut a: Box<_> = box A { x: box 0, y: 1 }; let _x = &mut a.x; <del> let _y = &a.y; //~ ERROR cannot borrow //~^ immutable borrow occurs here (via `a.y`) </del> <ins> let _y = &a.y; //[ast]~ ERROR cannot borrow //[ast]~^ immutable borrow occurs here (via `a.y`) use_mut(_x); </ins> } fn mut_borrow_after_borrow() { let mut a: Box<_> = box A { x: box 0, y: 1 }; let _x = &a.x; <del> let _y = &mut a.y; //~ ERROR cannot borrow //~^ mutable borrow occurs here (via `a.y`) </del> <ins> let _y = &mut a.y; //[ast]~ ERROR cannot borrow //[ast]~^ mutable borrow occurs here (via `a.y`) use_imm(_x); </ins> } 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; <del> //~^ value moved here let _y = a.y; //~ ERROR use of collaterally moved //~| value used here after move </del> <ins> //[ast]~^ value moved here let _y = a.y; //[ast]~ ERROR use of collaterally moved //[ast]~| value used here after move </ins> } 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; <del> //~^ value moved here let _y = a.y; //~ ERROR use of collaterally moved //~| value used here after move </del> <ins> //[ast]~^ value moved here let _y = a.y; //[ast]~ ERROR use of collaterally moved //[ast]~| value used here after move </ins> } 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; <del> //~^ value moved here let _y = &a.y; //~ ERROR use of collaterally moved //~| value used here after move </del> <ins> //[ast]~^ value moved here let _y = &a.y; //[ast]~ ERROR use of collaterally moved //[ast]~| value used here after move </ins> } 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; <del> //~^ borrow of `a.x.x` occurs here </del> <ins> //[ast]~^ borrow of `a.x.x` occurs here </ins> let _y = a.y; <del> //~^ ERROR cannot move //~| move out of </del> <ins> //[ast]~^ ERROR cannot move //[ast]~| move out of use_imm(_x); </ins> } fn copy_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; <del> let _y = a.y; //~ ERROR cannot use </del> <ins> let _y = a.y; //[ast]~ ERROR cannot use use_mut(_x); </ins> } fn move_after_mut_borrow_nested() { let mut a: Box<_> = box D { x: box A { x: box 0, y: 1 }, y: box 2 }; let _x = &mut a.x.x; let _y = a.y; <del> //~^ ERROR cannot move //~| move out of </del> <ins> //[ast]~^ ERROR cannot move //[ast]~| move out of use_mut(_x); </ins> } 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; <del> //~^ mutable borrow occurs here let _y = &a.y; //~ ERROR cannot borrow //~^ immutable borrow occurs here </del> <ins> //[ast]~^ mutable borrow occurs here let _y = &a.y; //[ast]~ ERROR cannot borrow //[ast]~^ immutable borrow occurs here use_mut(_x); </ins> } 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; <del> //~^ immutable borrow occurs here let _y = &mut a.y; //~ ERROR cannot borrow //~^ mutable borrow occurs here </del> <ins> //[ast]~^ immutable borrow occurs here let _y = &mut a.y; //[ast]~ ERROR cannot borrow //[ast]~^ mutable borrow occurs here use_imm(_x); </ins> } #[rustc_error] <del> fn main() { </del> <ins> fn main() { //[mir]~ ERROR compilation successful </ins> copy_after_move(); move_after_move(); borrow_after_move();

Discussion:
The revision system lets encode different sets of errors for different invocations of the compiler. and normally attempts to catch cases where you left out expected error messages by saying "if you have any annotation in your file, then the set of such annotations needs to match the same set of errors that are actually emitted. However, if you combine these features, then for each revision (call it ) in the revisions list, at least one of your errors currently need to be written with the revision system in mind, e.g. If none of the error annotations include a revision (i.e., if they are all ), then thinks that the test has no error annotations, and thus treats it as a case where the compiler's error output is blindly accepted. That seems bad.
cc
This is surely no longer the case, because and annotations are now mandatory?
With annotation for warnings and errors being mandatory , and additionally annotations applying to all revisions , this should be non-issue.