Add more borrowck tests for functional update moves

Add more borrowck field-sensitivity tests for functional update moves.
This makes the collection of test functions more combinatorially
exhaustive.

Author: Cameron Zwarich

src/test/run-pass/borrowck-field-sensitivity.rs

@@ -125,41 +125,83 @@ fn copy_after_assign_after_move() {
     drop(*x.b);
 }
 
+fn copy_after_assign_after_fu_move() {
+    let mut x = A { a: 1, b: box 2 };
+    let _y = A { a: 3, .. x };
+    x = A { a: 3, b: box 4 };
+    drop(*x.b);
+}
+
 fn copy_after_field_assign_after_move() {
     let mut x = A { a: 1, b: box 2 };
     drop(x.b);
     x.b = box 3;
     drop(*x.b);
 }
 
+fn copy_after_field_assign_after_fu_move() {
+    let mut x = A { a: 1, b: box 2 };
+    let _y = A { a: 3, .. x };
+    x.b = box 3;
+    drop(*x.b);
+}
+
 fn borrow_after_assign_after_move() {
     let mut x = A { a: 1, b: box 2 };
     drop(x.b);
     x = A { a: 3, b: box 4 };
     borrow(&x.b);
 }
 
+fn borrow_after_assign_after_fu_move() {
+    let mut x = A { a: 1, b: box 2 };
+    let _y = A { a: 3, .. x };
+    x = A { a: 3, b: box 4 };
+    borrow(&x.b);
+}
+
 fn borrow_after_field_assign_after_move() {
     let mut x = A { a: 1, b: box 2 };
     drop(x.b);
     x.b = box 3;
     borrow(&x.b);
 }
 
+fn borrow_after_field_assign_after_fu_move() {
+    let mut x = A { a: 1, b: box 2 };
+    let _y = A { a: 3, .. x };
+    x.b = box 3;
+    borrow(&x.b);
+}
+
 fn move_after_assign_after_move() {
     let mut x = A { a: 1, b: box 2 };
     let _y = x.b;
     x = A { a: 3, b: box 4 };
     drop(x.b);
 }
 
+fn move_after_assign_after_fu_move() {
+    let mut x = A { a: 1, b: box 2 };
+    let _y = A { a: 3, .. x };
+    x = A { a: 3, b: box 4 };
+    drop(x.b);
+}
+
 fn move_after_field_assign_after_move() {
     let mut x = A { a: 1, b: box 2 };
     drop(x.b);
     x.b = box 3;
     drop(x.b);
 }
 
+fn move_after_field_assign_after_fu_move() {
+    let mut x = A { a: 1, b: box 2 };
+    let _y = A { a: 3, .. x };
+    x.b = box 3;
+    drop(x.b);
+}
+
 fn copy_after_assign_after_uninit() {
     let mut x: A;
     x = A { a: 1, b: box 2 };
@@ -200,11 +242,19 @@ fn main() {
     fu_move_after_fu_move();
 
     copy_after_assign_after_move();
+    copy_after_assign_after_fu_move();
     copy_after_field_assign_after_move();
+    copy_after_field_assign_after_fu_move();
+
     borrow_after_assign_after_move();
+    borrow_after_assign_after_fu_move();
     borrow_after_field_assign_after_move();
+    borrow_after_field_assign_after_fu_move();
+
     move_after_assign_after_move();
+    move_after_assign_after_fu_move();
     move_after_field_assign_after_move();
+    move_after_field_assign_after_fu_move();
 
     copy_after_assign_after_uninit();
     borrow_after_assign_after_uninit();