generate reborrow constraints at type check time

Author: nikomatsakis

src/librustc_mir/borrow_check/nll/constraint_generation.rs

@@ -13,14 +13,11 @@ use borrow_check::location::LocationTable;
 use borrow_check::nll::ToRegionVid;
 use borrow_check::nll::facts::AllFacts;
 use borrow_check::nll::region_infer::RegionInferenceContext;
-use borrow_check::nll::type_check::AtLocation;
-use rustc::hir;
 use rustc::infer::InferCtxt;
 use rustc::mir::visit::TyContext;
 use rustc::mir::visit::Visitor;
-use rustc::mir::Place::Projection;
 use rustc::mir::{BasicBlock, BasicBlockData, Location, Mir, Place, Rvalue};
-use rustc::mir::{Local, PlaceProjection, ProjectionElem, Statement, Terminator};
+use rustc::mir::{Local, Statement, Terminator};
 use rustc::ty::fold::TypeFoldable;
 use rustc::ty::subst::Substs;
 use rustc::ty::{self, CanonicalTy, ClosureSubsts, GeneratorSubsts};
@@ -41,7 +38,6 @@ pub(super) fn generate_constraints<'cx, 'gcx, 'tcx>(
         regioncx,
         location_table,
         all_facts,
-        mir,
     };
 
     cg.add_region_liveness_constraints_from_type_check(liveness_set_from_typeck);
@@ -57,7 +53,6 @@ struct ConstraintGeneration<'cg, 'cx: 'cg, 'gcx: 'tcx, 'tcx: 'cx> {
     all_facts: &'cg mut Option<AllFacts>,
     location_table: &'cg LocationTable,
     regioncx: &'cg mut RegionInferenceContext<'tcx>,
-    mir: &'cg Mir<'tcx>,
     borrow_set: &'cg BorrowSet<'tcx>,
 }
 
@@ -184,41 +179,6 @@ impl<'cg, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'gcx
         self.super_terminator(block, terminator, location);
     }
 
-    fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
-        debug!("visit_rvalue(rvalue={:?}, location={:?})", rvalue, location);
-
-        match rvalue {
-            Rvalue::Ref(region, _borrow_kind, borrowed_place) => {
-                // In some cases, e.g. when borrowing from an unsafe
-                // place, we don't bother to create a loan, since
-                // there are no conditions to validate.
-                if let Some(all_facts) = self.all_facts {
-                    if let Some(borrow_index) = self.borrow_set.location_map.get(&location) {
-                        let region_vid = region.to_region_vid();
-                        all_facts.borrow_region.push((
-                            region_vid,
-                            *borrow_index,
-                            self.location_table.mid_index(location),
-                        ));
-                    }
-                }
-
-                // Look for an rvalue like:
-                //
-                //     & L
-                //
-                // where L is the path that is borrowed. In that case, we have
-                // to add the reborrow constraints (which don't fall out
-                // naturally from the type-checker).
-                self.add_reborrow_constraint(location, region, borrowed_place);
-            }
-
-            _ => {}
-        }
-
-        self.super_rvalue(rvalue, location);
-    }
-
     fn visit_user_assert_ty(
         &mut self,
         _c_ty: &CanonicalTy<'tcx>,
@@ -285,100 +245,4 @@ impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
                 self.regioncx.add_live_point(vid, location);
             });
     }
-
-    // Add the reborrow constraint at `location` so that `borrowed_place`
-    // is valid for `borrow_region`.
-    fn add_reborrow_constraint(
-        &mut self,
-        location: Location,
-        borrow_region: ty::Region<'tcx>,
-        borrowed_place: &Place<'tcx>,
-    ) {
-        let mut borrowed_place = borrowed_place;
-
-        debug!(
-            "add_reborrow_constraint({:?}, {:?}, {:?})",
-            location, borrow_region, borrowed_place
-        );
-        while let Projection(box PlaceProjection { base, elem }) = borrowed_place {
-            debug!("add_reborrow_constraint - iteration {:?}", borrowed_place);
-
-            match *elem {
-                ProjectionElem::Deref => {
-                    let tcx = self.infcx.tcx;
-                    let base_ty = base.ty(self.mir, tcx).to_ty(tcx);
-
-                    debug!("add_reborrow_constraint - base_ty = {:?}", base_ty);
-                    match base_ty.sty {
-                        ty::TyRef(ref_region, _, mutbl) => {
-                            self.regioncx.add_outlives(
-                                location.boring(),
-                                ref_region.to_region_vid(),
-                                borrow_region.to_region_vid(),
-                            );
-
-                            if let Some(all_facts) = self.all_facts {
-                                all_facts.outlives.push((
-                                    ref_region.to_region_vid(),
-                                    borrow_region.to_region_vid(),
-                                    self.location_table.mid_index(location),
-                                ));
-                            }
-
-                            match mutbl {
-                                hir::Mutability::MutImmutable => {
-                                    // Immutable reference. We don't need the base
-                                    // to be valid for the entire lifetime of
-                                    // the borrow.
-                                    break;
-                                }
-                                hir::Mutability::MutMutable => {
-                                    // Mutable reference. We *do* need the base
-                                    // to be valid, because after the base becomes
-                                    // invalid, someone else can use our mutable deref.
-
-                                    // This is in order to make the following function
-                                    // illegal:
-                                    // ```
-                                    // fn unsafe_deref<'a, 'b>(x: &'a &'b mut T) -> &'b mut T {
-                                    //     &mut *x
-                                    // }
-                                    // ```
-                                    //
-                                    // As otherwise you could clone `&mut T` using the
-                                    // following function:
-                                    // ```
-                                    // fn bad(x: &mut T) -> (&mut T, &mut T) {
-                                    //     let my_clone = unsafe_deref(&'a x);
-                                    //     ENDREGION 'a;
-                                    //     (my_clone, x)
-                                    // }
-                                    // ```
-                                }
-                            }
-                        }
-                        ty::TyRawPtr(..) => {
-                            // deref of raw pointer, guaranteed to be valid
-                            break;
-                        }
-                        ty::TyAdt(def, _) if def.is_box() => {
-                            // deref of `Box`, need the base to be valid - propagate
-                        }
-                        _ => bug!("unexpected deref ty {:?} in {:?}", base_ty, borrowed_place),
-                    }
-                }
-                ProjectionElem::Field(..)
-                | ProjectionElem::Downcast(..)
-                | ProjectionElem::Index(..)
-                | ProjectionElem::ConstantIndex { .. }
-                | ProjectionElem::Subslice { .. } => {
-                    // other field access
-                }
-            }
-
-            // The "propagate" case. We need to check that our base is valid
-            // for the borrow's lifetime.
-            borrowed_place = base;
-        }
-    }
 }

src/librustc_mir/borrow_check/nll/mod.rs

@@ -108,6 +108,7 @@ pub(in borrow_check) fn compute_regions<'cx, 'gcx, 'tcx>(
         def_id,
         &universal_regions,
         location_table,
+        borrow_set,
         &liveness,
         &mut all_facts,
         flow_inits,

src/librustc_mir/borrow_check/nll/region_infer/mod.rs

@@ -333,17 +333,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         self.liveness_constraints.add_element(v, element)
     }
 
-    /// Indicates that the region variable `sup` must outlive `sub` is live at the point `point`.
-    pub(super) fn add_outlives(&mut self, locations: Locations, sup: RegionVid, sub: RegionVid) {
-        assert!(self.inferred_values.is_none(), "values already inferred");
-        self.constraints.push(OutlivesConstraint {
-            locations,
-            sup,
-            sub,
-            next: None,
-        })
-    }
-
     /// Perform region inference and report errors if we see any
     /// unsatisfiable constraints. If this is a closure, returns the
     /// region requirements to propagate to our creator, if any.