Auto merge of #44811 - zilbuz:issue-44596/E0506, r=arielb1

bors · bors · commit a379780fb667 · 2017-09-29T03:54:12.000Z
MIR-borrowck: Adding notes to E0506 This PR adds notes to the MIR borrowck error E0506. Part of #44596
diff --git a/src/librustc_mir/borrow_check.rs b/src/librustc_mir/borrow_check.rs
@@ -412,7 +412,7 @@ impl<'c, 'b, 'a: 'b+'c, 'gcx, 'tcx: 'a> MirBorrowckCtxt<'c, 'b, 'a, 'gcx, 'tcx>
                             WriteKind::StorageDead |
                             WriteKind::Mutate =>
                                 this.report_illegal_mutation_of_borrowed(
-                                    context, lvalue_span),
+                                    context, lvalue_span, borrow),
                             WriteKind::Move =>
                                 this.report_move_out_while_borrowed(
                                     context, lvalue_span, borrow),
@@ -987,10 +987,19 @@ impl<'c, 'b, 'a: 'b+'c, 'gcx, 'tcx: 'a> MirBorrowckCtxt<'c, 'b, 'a, 'gcx, 'tcx>
         err.emit();
     }
 
-    fn report_illegal_mutation_of_borrowed(&mut self, _: Context, (lvalue, span): (&Lvalue, Span)) {
+    fn report_illegal_mutation_of_borrowed(&mut self,
+                                           _: Context,
+                                           (lvalue, span): (&Lvalue, Span),
+                                           loan: &BorrowData) {
+        let describe_lvalue = self.describe_lvalue(lvalue);
+        let borrow_span = self.retrieve_borrow_span(loan);
+
         let mut err = self.tcx.cannot_assign_to_borrowed(
             span, &self.describe_lvalue(lvalue), Origin::Mir);
-        // FIXME: add span labels for borrow and assignment points
+
+        err.span_label(borrow_span, format!("borrow of `{}` occurs here", describe_lvalue));
+        err.span_label(span, format!("assignment to borrowed `{}` occurs here", describe_lvalue));
+
         err.emit();
     }
 
diff --git a/src/test/compile-fail/E0506.rs b/src/test/compile-fail/E0506.rs
@@ -8,14 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 struct FancyNum {
     num: u8,
 }
 
 fn main() {
     let mut fancy_num = FancyNum { num: 5 };
     let fancy_ref = &fancy_num;
-    fancy_num = FancyNum { num: 6 }; //~ ERROR E0506
+    fancy_num = FancyNum { num: 6 }; //[ast]~ ERROR E0506
+                                     //[mir]~^ ERROR (Mir) [E0506]
+                                     //[mir]~| ERROR (Ast) [E0506]
 
     println!("Num: {}, Ref: {}", fancy_num.num, fancy_ref.num);
 }
diff --git a/src/test/compile-fail/borrowck/borrowck-assign-comp.rs b/src/test/compile-fail/borrowck/borrowck-assign-comp.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 struct point { x: isize, y: isize }
 
 fn a() {
@@ -17,7 +20,9 @@ fn a() {
     // This assignment is illegal because the field x is not
     // inherently mutable; since `p` was made immutable, `p.x` is now
     // immutable.  Otherwise the type of &_q.x (&isize) would be wrong.
-    p.x = 5; //~ ERROR cannot assign to `p.x`
+    p.x = 5; //[ast]~ ERROR cannot assign to `p.x`
+             //[mir]~^ ERROR cannot assign to `p.x` because it is borrowed (Ast)
+             //[mir]~| ERROR cannot assign to `p.0` because it is borrowed (Mir)
     q.x;
 }
 
@@ -27,7 +32,9 @@ fn c() {
 
     let mut p = point {x: 3, y: 4};
     let q = &p.y;
-    p = point {x: 5, y: 7};//~ ERROR cannot assign to `p`
+    p = point {x: 5, y: 7};//[ast]~ ERROR cannot assign to `p`
+                           //[mir]~^ ERROR cannot assign to `p` because it is borrowed (Ast)
+                           //[mir]~| ERROR cannot assign to `p` because it is borrowed (Mir)
     p.x; // silence warning
     *q; // stretch loan
 }
@@ -38,7 +45,9 @@ fn d() {
 
     let mut p = point {x: 3, y: 4};
     let q = &p.y;
-    p.y = 5; //~ ERROR cannot assign to `p.y`
+    p.y = 5; //[ast]~ ERROR cannot assign to `p.y`
+             //[mir]~^ ERROR cannot assign to `p.y` because it is borrowed (Ast)
+             //[mir]~| ERROR cannot assign to `p.1` because it is borrowed (Mir)
     *q;
 }
 
diff --git a/src/test/compile-fail/borrowck/borrowck-closures-mut-and-imm.rs b/src/test/compile-fail/borrowck/borrowck-closures-mut-and-imm.rs
@@ -11,6 +11,10 @@
 // Tests that two closures cannot simultaneously have mutable
 // and immutable access to the variable. Issue #6801.
 
+// ignore-tidy-linelength
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 #![feature(box_syntax)]
 
 fn get(x: &isize) -> isize {
@@ -24,37 +28,49 @@ fn set(x: &mut isize) {
 fn a() {
     let mut x = 3;
     let c1 = || x = 4;
-    let c2 = || x * 5; //~ ERROR cannot borrow `x`
+    let c2 = || x * 5; //[ast]~ ERROR cannot borrow `x`
+                       //[mir]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable (Ast)
+                       //[mir]~| ERROR cannot borrow `x` as immutable because it is also borrowed as mutable (Mir)
 }
 
 fn b() {
     let mut x = 3;
     let c1 = || set(&mut x);
-    let c2 = || get(&x); //~ ERROR cannot borrow `x`
+    let c2 = || get(&x); //[ast]~ ERROR cannot borrow `x`
+                         //[mir]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable (Ast)
+                         //[mir]~| ERROR cannot borrow `x` as immutable because it is also borrowed as mutable (Mir)
 }
 
 fn c() {
     let mut x = 3;
     let c1 = || set(&mut x);
-    let c2 = || x * 5; //~ ERROR cannot borrow `x`
+    let c2 = || x * 5; //[ast]~ ERROR cannot borrow `x`
+                       //[mir]~^ ERROR cannot borrow `x` as immutable because it is also borrowed as mutable (Ast)
+                       //[mir]~| ERROR cannot borrow `x` as immutable because it is also borrowed as mutable (Mir)
 }
 
 fn d() {
     let mut x = 3;
     let c2 = || x * 5;
-    x = 5; //~ ERROR cannot assign
+    x = 5; //[ast]~ ERROR cannot assign
+           //[mir]~^ ERROR cannot assign to `x` because it is borrowed (Ast)
+           //[mir]~| ERROR cannot assign to `x` because it is borrowed (Mir)
 }
 
 fn e() {
     let mut x = 3;
     let c1 = || get(&x);
-    x = 5; //~ ERROR cannot assign
+    x = 5; //[ast]~ ERROR cannot assign
+           //[mir]~^ ERROR cannot assign to `x` because it is borrowed (Ast)
+           //[mir]~| ERROR cannot assign to `x` because it is borrowed (Mir)
 }
 
 fn f() {
     let mut x: Box<_> = box 3;
     let c1 = || get(&*x);
-    *x = 5; //~ ERROR cannot assign
+    *x = 5; //[ast]~ ERROR cannot assign
+            //[mir]~^ ERROR cannot assign to `*x` because it is borrowed (Ast)
+            //[mir]~| ERROR cannot assign to `(*x)` because it is borrowed (Mir)
 }
 
 fn g() {
@@ -64,7 +80,9 @@ fn g() {
 
     let mut x: Box<_> = box Foo { f: box 3 };
     let c1 = || get(&*x.f);
-    *x.f = 5; //~ ERROR cannot assign to `*x.f`
+    *x.f = 5; //[ast]~ ERROR cannot assign to `*x.f`
+              //[mir]~^ ERROR cannot assign to `*x.f` because it is borrowed (Ast)
+              //[mir]~| ERROR cannot assign to `(*(*x).0)` because it is borrowed (Mir)
 }
 
 fn h() {
@@ -74,7 +92,9 @@ fn h() {
 
     let mut x: Box<_> = box Foo { f: box 3 };
     let c1 = || get(&*x.f);
-    let c2 = || *x.f = 5; //~ ERROR cannot borrow `x` as mutable
+    let c2 = || *x.f = 5; //[ast]~ ERROR cannot borrow `x` as mutable
+                          //[mir]~^ ERROR cannot borrow `x` as mutable because it is also borrowed as immutable (Ast)
+                          //[mir]~| ERROR cannot borrow `x` as mutable because it is also borrowed as immutable (Mir)
 }
 
 fn main() {
diff --git a/src/test/compile-fail/borrowck/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.rs b/src/test/compile-fail/borrowck/borrowck-imm-ref-to-mut-rec-field-issue-3162-c.rs
@@ -8,11 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 fn main() {
     let mut _a = 3;
     let _b = &mut _a;
     {
         let _c = &*_b;
-        _a = 4; //~ ERROR cannot assign to `_a`
+        _a = 4; //[ast]~ ERROR cannot assign to `_a`
+                //[mir]~^ ERROR cannot assign to `_a` because it is borrowed (Ast)
+                //[mir]~| ERROR cannot assign to `_a` because it is borrowed (Mir)
     }
 }
diff --git a/src/test/compile-fail/borrowck/borrowck-lend-flow-match.rs b/src/test/compile-fail/borrowck/borrowck-lend-flow-match.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 #![allow(unused_variables)]
 #![allow(unused_assignments)]
 
@@ -22,7 +25,9 @@ fn separate_arms() {
             x = Some(0);
         }
         Some(ref __isize) => {
-            x = Some(1); //~ ERROR cannot assign
+            x = Some(1); //[ast]~ ERROR cannot assign
+                         //[mir]~^ ERROR cannot assign to `x` because it is borrowed (Ast)
+                         //[mir]~| ERROR cannot assign to `x` because it is borrowed (Mir)
         }
     }
     x.clone(); // just to prevent liveness warnings
diff --git a/src/test/compile-fail/borrowck/borrowck-overloaded-index-and-overloaded-deref.rs b/src/test/compile-fail/borrowck/borrowck-overloaded-index-and-overloaded-deref.rs
@@ -13,6 +13,9 @@
 // operator. The accounting of the all the implicit things going on
 // here is rather subtle. Issue #20232.
 
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 use std::ops::{Deref, Index};
 
 struct MyVec<T> { x: T }
@@ -39,7 +42,9 @@ fn main() {
     let mut v = MyVec { x: MyPtr { x: Foo { f: 22 } } };
     let i = &v[0].f;
     v = MyVec { x: MyPtr { x: Foo { f: 23 } } };
-    //~^ ERROR cannot assign to `v`
+    //[ast]~^ ERROR cannot assign to `v`
+    //[mir]~^^ ERROR cannot assign to `v` because it is borrowed (Ast)
+    //[mir]~| ERROR cannot assign to `v` because it is borrowed (Mir)
     read(*i);
 }
 
diff --git a/src/test/compile-fail/borrowck/borrowck-pat-reassign-binding.rs b/src/test/compile-fail/borrowck/borrowck-pat-reassign-binding.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 fn main() {
     let mut x: Option<isize> = None;
     match x {
@@ -17,7 +20,9 @@ fn main() {
       }
       Some(ref i) => {
           // But on this branch, `i` is an outstanding borrow
-          x = Some(*i+1); //~ ERROR cannot assign to `x`
+          x = Some(*i+1); //[ast]~ ERROR cannot assign to `x`
+                          //[mir]~^ ERROR cannot assign to `x` because it is borrowed (Ast)
+                          //[mir]~| ERROR cannot assign to `x` because it is borrowed (Mir)
       }
     }
     x.clone(); // just to prevent liveness warnings
diff --git a/src/test/compile-fail/borrowck/borrowck-union-borrow.rs b/src/test/compile-fail/borrowck/borrowck-union-borrow.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 // ignore-tidy-linelength
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
 
 #[derive(Clone, Copy)]
 union U {
@@ -30,11 +32,15 @@ fn main() {
         }
         {
             let ra = &u.a;
-            let rma = &mut u.a; //~ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable
+            let rma = &mut u.a; //[ast]~ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable
+                                //[mir]~^ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable (Ast)
+                                //[mir]~| ERROR cannot borrow `u.0` as mutable because it is also borrowed as immutable (Mir)
         }
         {
             let ra = &u.a;
-            u.a = 1; //~ ERROR cannot assign to `u.a` because it is borrowed
+            u.a = 1; //[ast]~ ERROR cannot assign to `u.a` because it is borrowed
+                     //[mir]~^ ERROR cannot assign to `u.a` because it is borrowed (Ast)
+                     //[mir]~| ERROR cannot assign to `u.0` because it is borrowed (Mir)
         }
         // Imm borrow, other field
         {
@@ -47,45 +53,65 @@ fn main() {
         }
         {
             let ra = &u.a;
-            let rmb = &mut u.b; //~ ERROR cannot borrow `u` (via `u.b`) as mutable because `u` is also borrowed as immutable (via `u.a`)
+            let rmb = &mut u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as mutable because `u` is also borrowed as immutable (via `u.a`)
+                                //[mir]~^ ERROR cannot borrow `u` (via `u.b`) as mutable because `u` is also borrowed as immutable (via `u.a`) (Ast)
+                                // FIXME Error for MIR (needs support for union)
         }
         {
             let ra = &u.a;
-            u.b = 1; //~ ERROR cannot assign to `u.b` because it is borrowed
+            u.b = 1; //[ast]~ ERROR cannot assign to `u.b` because it is borrowed
+                     //[mir]~^ ERROR cannot assign to `u.b` because it is borrowed (Ast)
+                     // FIXME Error for MIR (needs support for union)
         }
         // Mut borrow, same field
         {
             let rma = &mut u.a;
-            let ra = &u.a; //~ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable
+            let ra = &u.a; //[ast]~ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable
+                         //[mir]~^ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable (Ast)
+                         //[mir]~| ERROR cannot borrow `u.0` as immutable because it is also borrowed as mutable (Mir)
         }
         {
             let ra = &mut u.a;
-            let a = u.a; //~ ERROR cannot use `u.a` because it was mutably borrowed
+            let a = u.a; //[ast]~ ERROR cannot use `u.a` because it was mutably borrowed
+                         //[mir]~^ ERROR cannot use `u.a` because it was mutably borrowed (Ast)
+                         //[mir]~| ERROR cannot use `u.0` because it was mutably borrowed (Mir)
         }
         {
             let rma = &mut u.a;
-            let rma2 = &mut u.a; //~ ERROR cannot borrow `u.a` as mutable more than once at a time
+            let rma2 = &mut u.a; //[ast]~ ERROR cannot borrow `u.a` as mutable more than once at a time
+                                 //[mir]~^ ERROR cannot borrow `u.a` as mutable more than once at a time (Ast)
+                                 //[mir]~| ERROR cannot borrow `u.0` as mutable more than once at a time (Mir)
         }
         {
             let rma = &mut u.a;
-            u.a = 1; //~ ERROR cannot assign to `u.a` because it is borrowed
+            u.a = 1; //[ast]~ ERROR cannot assign to `u.a` because it is borrowed
+                     //[mir]~^ ERROR cannot assign to `u.a` because it is borrowed (Ast)
+                     //[mir]~| ERROR cannot assign to `u.0` because it is borrowed (Mir)
         }
         // Mut borrow, other field
         {
             let rma = &mut u.a;
-            let rb = &u.b; //~ ERROR cannot borrow `u` (via `u.b`) as immutable because `u` is also borrowed as mutable (via `u.a`)
+            let rb = &u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as immutable because `u` is also borrowed as mutable (via `u.a`)
+                           //[mir]~^ ERROR cannot borrow `u` (via `u.b`) as immutable because `u` is also borrowed as mutable (via `u.a`) (Ast)
+                           // FIXME Error for MIR (needs support for union)
         }
         {
             let ra = &mut u.a;
-            let b = u.b; //~ ERROR cannot use `u.b` because it was mutably borrowed
+            let b = u.b; //[ast]~ ERROR cannot use `u.b` because it was mutably borrowed
+                         //[mir]~^ ERROR cannot use `u.b` because it was mutably borrowed (Ast)
+                         // FIXME Error for MIR (needs support for union)
         }
         {
             let rma = &mut u.a;
-            let rmb2 = &mut u.b; //~ ERROR cannot borrow `u` (via `u.b`) as mutable more than once at a time
+            let rmb2 = &mut u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as mutable more than once at a time
+                                 //[mir]~^ ERROR cannot borrow `u` (via `u.b`) as mutable more than once at a time (Ast)
+                                 // FIXME Error for MIR (needs support for union)
         }
         {
             let rma = &mut u.a;
-            u.b = 1; //~ ERROR cannot assign to `u.b` because it is borrowed
+            u.b = 1; //[ast]~ ERROR cannot assign to `u.b` because it is borrowed
+                     //[mir]~^ ERROR cannot assign to `u.b` because it is borrowed (Ast)
+                     // FIXME Error for MIR (needs support for union)
         }
     }
 }
diff --git a/src/test/compile-fail/borrowck/borrowck-vec-pattern-move-tail.rs b/src/test/compile-fail/borrowck/borrowck-vec-pattern-move-tail.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// revisions: ast mir
+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir
+
 #![feature(slice_patterns)]
 
 fn main() {
@@ -17,7 +20,9 @@ fn main() {
         _ => unreachable!()
     };
     println!("t[0]: {}", t[0]);
-    a[2] = 0; //~ ERROR cannot assign to `a[..]` because it is borrowed
+    a[2] = 0; //[ast]~ ERROR cannot assign to `a[..]` because it is borrowed
+              //[mir]~^ ERROR cannot assign to `a[..]` because it is borrowed (Ast)
+              // FIXME Error for MIR (error missed)
     println!("t[0]: {}", t[0]);
     t[0];
 }
diff --git a/src/test/compile-fail/coerce-overloaded-autoderef.rs b/src/test/compile-fail/coerce-overloaded-autoderef.rs
diff --git a/src/test/compile-fail/hrtb-identity-fn-borrows.rs b/src/test/compile-fail/hrtb-identity-fn-borrows.rs
diff --git a/src/test/compile-fail/mut-pattern-internal-mutability.rs b/src/test/compile-fail/mut-pattern-internal-mutability.rs
diff --git a/src/test/compile-fail/regions-pattern-typing-issue-19997.rs b/src/test/compile-fail/regions-pattern-typing-issue-19997.rs

Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,16 @@`
`8`	`8`	`// option. This file may not be copied, modified, or distributed`
`9`	`9`	`// except according to those terms.`
`10`	`10`
	`11`	`+// revisions: ast mir`
	`12`	`+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir`
	`13`	`+`
`11`	`14`	`fn main() {`
`12`	`15`	`let mut _a = 3;`
`13`	`16`	`let _b = &mut _a;`
`14`	`17`	`{`
`15`	`18`	`let _c = &*_b;`
`16`		- _a = 4; //~ ERROR cannot assign to `_a`
	`19`	+ _a = 4; //[ast]~ ERROR cannot assign to `_a`
	`20`	+ //[mir]~^ ERROR cannot assign to `_a` because it is borrowed (Ast)
	`21`	+ //[mir]~\| ERROR cannot assign to `_a` because it is borrowed (Mir)
`17`	`22`	`}`
`18`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,9 @@`
`8`	`8`	`// option. This file may not be copied, modified, or distributed`
`9`	`9`	`// except according to those terms.`
`10`	`10`
	`11`	`+// revisions: ast mir`
	`12`	`+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir`
	`13`	`+`
`11`	`14`	`#![allow(unused_variables)]`
`12`	`15`	`#![allow(unused_assignments)]`
`13`	`16`
`@@ -22,7 +25,9 @@ fn separate_arms() {`
`22`	`25`	`x = Some(0);`
`23`	`26`	`}`
`24`	`27`	`Some(ref __isize) => {`
`25`		`- x = Some(1); //~ ERROR cannot assign`
	`28`	`+ x = Some(1); //[ast]~ ERROR cannot assign`
	`29`	+ //[mir]~^ ERROR cannot assign to `x` because it is borrowed (Ast)
	`30`	+ //[mir]~\| ERROR cannot assign to `x` because it is borrowed (Mir)
`26`	`31`	`}`
`27`	`32`	`}`
`28`	`33`	`x.clone(); // just to prevent liveness warnings`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`	`// except according to those terms.`
`10`	`10`
`11`	`11`	`// ignore-tidy-linelength`
	`12`	`+// revisions: ast mir`
	`13`	`+//[mir]compile-flags: -Z emit-end-regions -Z borrowck-mir`
`12`	`14`
`13`	`15`	`#[derive(Clone, Copy)]`
`14`	`16`	`union U {`
`@@ -30,11 +32,15 @@ fn main() {`
`30`	`32`	`}`
`31`	`33`	`{`
`32`	`34`	`let ra = &u.a;`
`33`		- let rma = &mut u.a; //~ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable
	`35`	+ let rma = &mut u.a; //[ast]~ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable
	`36`	+ //[mir]~^ ERROR cannot borrow `u.a` as mutable because it is also borrowed as immutable (Ast)
	`37`	+ //[mir]~\| ERROR cannot borrow `u.0` as mutable because it is also borrowed as immutable (Mir)
`34`	`38`	`}`
`35`	`39`	`{`
`36`	`40`	`let ra = &u.a;`
`37`		- u.a = 1; //~ ERROR cannot assign to `u.a` because it is borrowed
	`41`	+ u.a = 1; //[ast]~ ERROR cannot assign to `u.a` because it is borrowed
	`42`	+ //[mir]~^ ERROR cannot assign to `u.a` because it is borrowed (Ast)
	`43`	+ //[mir]~\| ERROR cannot assign to `u.0` because it is borrowed (Mir)
`38`	`44`	`}`
`39`	`45`	`// Imm borrow, other field`
`40`	`46`	`{`
`@@ -47,45 +53,65 @@ fn main() {`
`47`	`53`	`}`
`48`	`54`	`{`
`49`	`55`	`let ra = &u.a;`
`50`		- let rmb = &mut u.b; //~ ERROR cannot borrow `u` (via `u.b`) as mutable because `u` is also borrowed as immutable (via `u.a`)
	`56`	+ let rmb = &mut u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as mutable because `u` is also borrowed as immutable (via `u.a`)
	`57`	+ //[mir]~^ ERROR cannot borrow `u` (via `u.b`) as mutable because `u` is also borrowed as immutable (via `u.a`) (Ast)
	`58`	`+ // FIXME Error for MIR (needs support for union)`
`51`	`59`	`}`
`52`	`60`	`{`
`53`	`61`	`let ra = &u.a;`
`54`		- u.b = 1; //~ ERROR cannot assign to `u.b` because it is borrowed
	`62`	+ u.b = 1; //[ast]~ ERROR cannot assign to `u.b` because it is borrowed
	`63`	+ //[mir]~^ ERROR cannot assign to `u.b` because it is borrowed (Ast)
	`64`	`+ // FIXME Error for MIR (needs support for union)`
`55`	`65`	`}`
`56`	`66`	`// Mut borrow, same field`
`57`	`67`	`{`
`58`	`68`	`let rma = &mut u.a;`
`59`		- let ra = &u.a; //~ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable
	`69`	+ let ra = &u.a; //[ast]~ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable
	`70`	+ //[mir]~^ ERROR cannot borrow `u.a` as immutable because it is also borrowed as mutable (Ast)
	`71`	+ //[mir]~\| ERROR cannot borrow `u.0` as immutable because it is also borrowed as mutable (Mir)
`60`	`72`	`}`
`61`	`73`	`{`
`62`	`74`	`let ra = &mut u.a;`
`63`		- let a = u.a; //~ ERROR cannot use `u.a` because it was mutably borrowed
	`75`	+ let a = u.a; //[ast]~ ERROR cannot use `u.a` because it was mutably borrowed
	`76`	+ //[mir]~^ ERROR cannot use `u.a` because it was mutably borrowed (Ast)
	`77`	+ //[mir]~\| ERROR cannot use `u.0` because it was mutably borrowed (Mir)
`64`	`78`	`}`
`65`	`79`	`{`
`66`	`80`	`let rma = &mut u.a;`
`67`		- let rma2 = &mut u.a; //~ ERROR cannot borrow `u.a` as mutable more than once at a time
	`81`	+ let rma2 = &mut u.a; //[ast]~ ERROR cannot borrow `u.a` as mutable more than once at a time
	`82`	+ //[mir]~^ ERROR cannot borrow `u.a` as mutable more than once at a time (Ast)
	`83`	+ //[mir]~\| ERROR cannot borrow `u.0` as mutable more than once at a time (Mir)
`68`	`84`	`}`
`69`	`85`	`{`
`70`	`86`	`let rma = &mut u.a;`
`71`		- u.a = 1; //~ ERROR cannot assign to `u.a` because it is borrowed
	`87`	+ u.a = 1; //[ast]~ ERROR cannot assign to `u.a` because it is borrowed
	`88`	+ //[mir]~^ ERROR cannot assign to `u.a` because it is borrowed (Ast)
	`89`	+ //[mir]~\| ERROR cannot assign to `u.0` because it is borrowed (Mir)
`72`	`90`	`}`
`73`	`91`	`// Mut borrow, other field`
`74`	`92`	`{`
`75`	`93`	`let rma = &mut u.a;`
`76`		- let rb = &u.b; //~ ERROR cannot borrow `u` (via `u.b`) as immutable because `u` is also borrowed as mutable (via `u.a`)
	`94`	+ let rb = &u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as immutable because `u` is also borrowed as mutable (via `u.a`)
	`95`	+ //[mir]~^ ERROR cannot borrow `u` (via `u.b`) as immutable because `u` is also borrowed as mutable (via `u.a`) (Ast)
	`96`	`+ // FIXME Error for MIR (needs support for union)`
`77`	`97`	`}`
`78`	`98`	`{`
`79`	`99`	`let ra = &mut u.a;`
`80`		- let b = u.b; //~ ERROR cannot use `u.b` because it was mutably borrowed
	`100`	+ let b = u.b; //[ast]~ ERROR cannot use `u.b` because it was mutably borrowed
	`101`	+ //[mir]~^ ERROR cannot use `u.b` because it was mutably borrowed (Ast)
	`102`	`+ // FIXME Error for MIR (needs support for union)`
`81`	`103`	`}`
`82`	`104`	`{`
`83`	`105`	`let rma = &mut u.a;`
`84`		- let rmb2 = &mut u.b; //~ ERROR cannot borrow `u` (via `u.b`) as mutable more than once at a time
	`106`	+ let rmb2 = &mut u.b; //[ast]~ ERROR cannot borrow `u` (via `u.b`) as mutable more than once at a time
	`107`	+ //[mir]~^ ERROR cannot borrow `u` (via `u.b`) as mutable more than once at a time (Ast)
	`108`	`+ // FIXME Error for MIR (needs support for union)`
`85`	`109`	`}`
`86`	`110`	`{`
`87`	`111`	`let rma = &mut u.a;`
`88`		- u.b = 1; //~ ERROR cannot assign to `u.b` because it is borrowed
	`112`	+ u.b = 1; //[ast]~ ERROR cannot assign to `u.b` because it is borrowed
	`113`	+ //[mir]~^ ERROR cannot assign to `u.b` because it is borrowed (Ast)
	`114`	`+ // FIXME Error for MIR (needs support for union)`
`89`	`115`	`}`
`90`	`116`	`}`
`91`	`117`	`}`