Mir tycheck aggregate rvalues

src/librustc_mir/transform/type_check.rs

@@ -549,6 +549,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                         terr
                     );
                 }
+                self.check_rvalue(mir, rv, location);
             }
             StatementKind::SetDiscriminant {
                 ref lvalue,
@@ -1008,6 +1009,102 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
         }
     }
 
+    fn aggregate_field_ty(&mut self, ak: &Box<AggregateKind<'tcx>>, field: usize, location: Location)
+        -> Result<Ty<'tcx>, FieldAccessError>
+    {
+        let tcx = self.tcx();
+
+        let (variant, substs) = match **ak {
+            AggregateKind::Adt(def, variant, substs, _) => { // handle unions?
+                (&def.variants[variant], substs)
+            },
+            AggregateKind::Closure(def_id, substs) => {
+                return match substs.upvar_tys(def_id, tcx).nth(field) {
+                    Some(ty) => Ok(ty),
+                    None => Err(FieldAccessError::OutOfRange {
+                        field_count: substs.upvar_tys(def_id, tcx).count()
+                    }),
+                }
+            },
+            AggregateKind::Generator(def_id, substs, _) => {
+                if let Some(ty) = substs.upvar_tys(def_id, tcx).nth(field) {
+                    return Ok(ty);
+                }
+
+                return match substs.field_tys(def_id, tcx).nth(field) {
+                    Some(ty) => Ok(ty),
+                    None => Err(FieldAccessError::OutOfRange {
+                        field_count: substs.field_tys(def_id, tcx).count() + 1
+                    }),
+                }
+            },
+            AggregateKind::Array(ty) => {
+                return Ok(ty);
+            },
+            AggregateKind::Tuple => {
+                unreachable!("This should have been covered in check_rvalues");
+            },
+        };
+
+        if let Some(field) = variant.fields.get(field) {
+            Ok(self.normalize(&field.ty(tcx, substs), location))
+        } else {
+            Err(FieldAccessError::OutOfRange { field_count: variant.fields.len() })
+        }
+    }
+
+    fn check_rvalue(&mut self, mir: &Mir<'tcx>, rv: &Rvalue<'tcx>, location: Location) {
+        let tcx = self.tcx();
+        match rv {
+            Rvalue::Aggregate(ak, ops) => {
+                match **ak {
+                    // tuple rvalue field type is always the type of the op. Nothing to check here.
+                    AggregateKind::Tuple => { },
+                    _ => {
+                        for (i, op) in ops.iter().enumerate() {
+                            let field_ty = match self.aggregate_field_ty(ak, i, location) {
+                                Ok(field_ty) => field_ty,
+                                Err(FieldAccessError::OutOfRange { field_count }) => {
+                                    span_mirbug!(
+                                        self,
+                                        rv,
+                                        "accessed field #{} but variant only has {}",
+                                        i,
+                                        field_count);
+                                    continue;
+                                },
+                            };
+                            let op_ty = match op {
+                                Operand::Consume(lv) => lv.ty(mir, tcx).to_ty(tcx),
+                                Operand::Constant(c) => c.ty,
+                            };
+                            if let Err(terr) = self.sub_types(op_ty, field_ty, location.at_successor_within_block()) {
+                                span_mirbug!(
+                                    self,
+                                    rv,
+                                    "{:?} is not a subtype of {:?}: {:?}",
+                                    op_ty,
+                                    field_ty,
+                                    terr);
+                            }
+                        }
+                    },
+                }
+            },
+            // FIXME: These other cases have to be implemented in future PRs
+            Rvalue::Use(..) |
+            Rvalue::Repeat(..) |
+            Rvalue::Ref(..) |
+            Rvalue::Len(..) |
+            Rvalue::Cast(..) |
+            Rvalue::BinaryOp(..) |
+            Rvalue::CheckedBinaryOp(..) |
+            Rvalue::UnaryOp(..) |
+            Rvalue::Discriminant(..) |
+            Rvalue::NullaryOp(..) => { }
+        }
+    }
+
     fn typeck_mir(&mut self, mir: &Mir<'tcx>) {
         self.last_span = mir.span;
         debug!("run_on_mir: {:?}", mir.span);

src/test/compile-fail/nll/reference-carried-through-struct-field.rs

@@ -0,0 +1,27 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// 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 -Z nll
+
+#![allow(unused_assignments)]
+
+struct Wrap<'a> { w: &'a mut u32 }
+
+fn foo() {
+    let mut x = 22;
+    let wrapper = Wrap { w: &mut x };
+    x += 1; //[ast]~ ERROR cannot assign to `x` because it is borrowed [E0506]
+    //[mir]~^ ERROR cannot assign to `x` because it is borrowed (Ast) [E0506]
+    //[mir]~^^ ERROR cannot assign to `x` because it is borrowed (Mir) [E0506]
+    //[mir]~^^^ ERROR cannot use `x` because it was mutably borrowed (Mir) [E0503]
+    *wrapper.w += 1;
+}
+
+fn main() { }