integrate NLL with MIR type-checker

Author: nikomatsakis

src/librustc/middle/free_region.rs

@@ -192,7 +192,7 @@ impl<'tcx> FreeRegionMap<'tcx> {
     ///
     /// if `r_a` represents `'a`, this function would return `{'b, 'c}`.
     pub fn regions_that_outlive<'a, 'gcx>(&self, r_a: Region<'tcx>) -> Vec<&Region<'tcx>> {
-        assert!(is_free(r_a));
+        assert!(is_free(r_a) || *r_a == ty::ReStatic);
         self.relation.greater_than(&r_a)
     }
 }

src/librustc_mir/borrow_check.rs

@@ -112,7 +112,7 @@ fn do_mir_borrowck<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
     let opt_regioncx = if !tcx.sess.opts.debugging_opts.nll {
         None
     } else {
-        Some(nll::compute_regions(infcx, def_id, mir))
+        Some(nll::compute_regions(infcx, def_id, param_env, mir))
     };
 
     let mdpe = MoveDataParamEnv { move_data: move_data, param_env: param_env };

src/librustc_mir/transform/nll/constraint_generation.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use rustc::hir;
-use rustc::mir::{BasicBlock, BorrowKind, Location, Lvalue, Mir, Rvalue, Statement, StatementKind};
+use rustc::mir::{Location, Lvalue, Mir, Rvalue};
 use rustc::mir::visit::Visitor;
 use rustc::mir::Lvalue::Projection;
 use rustc::mir::{LvalueProjection, ProjectionElem};
@@ -21,7 +21,6 @@ use rustc::util::common::ErrorReported;
 use rustc_data_structures::fx::FxHashSet;
 use syntax::codemap::DUMMY_SP;
 
-use super::subtype;
 use super::LivenessResults;
 use super::ToRegionVid;
 use super::region_infer::RegionInferenceContext;
@@ -179,29 +178,6 @@ impl<'cx, 'gcx, 'tcx> ConstraintGeneration<'cx, 'gcx, 'tcx> {
         self.visit_mir(self.mir);
     }
 
-    fn add_borrow_constraint(
-        &mut self,
-        location: Location,
-        destination_lv: &Lvalue<'tcx>,
-        borrow_region: ty::Region<'tcx>,
-        _borrow_kind: BorrowKind,
-        _borrowed_lv: &Lvalue<'tcx>,
-    ) {
-        let tcx = self.infcx.tcx;
-        let span = self.mir.source_info(location).span;
-        let destination_ty = destination_lv.ty(self.mir, tcx).to_ty(tcx);
-
-        let destination_region = match destination_ty.sty {
-            ty::TyRef(r, _) => r,
-            _ => bug!()
-        };
-
-        self.regioncx.add_outlives(span,
-                                   borrow_region.to_region_vid(),
-                                   destination_region.to_region_vid(),
-                                   location.successor_within_block());
-    }
-
     fn add_reborrow_constraint(
         &mut self,
         location: Location,
@@ -237,35 +213,22 @@ impl<'cx, 'gcx, 'tcx> ConstraintGeneration<'cx, 'gcx, 'tcx> {
 }
 
 impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cx, 'gcx, 'tcx> {
-    fn visit_statement(&mut self,
-                       block: BasicBlock,
-                       statement: &Statement<'tcx>,
-                       location: Location) {
+    fn visit_rvalue(&mut self,
+                    rvalue: &Rvalue<'tcx>,
+                    location: Location) {
+        debug!("visit_rvalue(rvalue={:?}, location={:?})", rvalue, location);
 
-        debug!("visit_statement(statement={:?}, location={:?})", statement, location);
-
-        // Look for a statement like:
+        // Look for an rvalue like:
         //
-        //     D = & L
+        //     & L
         //
-        // where D is the path to which we are assigning, and
-        // L is the path that is borrowed.
-        if let StatementKind::Assign(ref destination_lv, ref rv) = statement.kind {
-            if let Rvalue::Ref(region, bk, ref borrowed_lv) = *rv {
-                self.add_borrow_constraint(location, destination_lv, region, bk, borrowed_lv);
-                self.add_reborrow_constraint(location, region, borrowed_lv);
-            }
-
-            let tcx = self.infcx.tcx;
-            let destination_ty = destination_lv.ty(self.mir, tcx).to_ty(tcx);
-            let rv_ty = rv.ty(self.mir, tcx);
-
-            let span = self.mir.source_info(location).span;
-            for (a, b) in subtype::outlives_pairs(tcx, rv_ty, destination_ty) {
-                self.regioncx.add_outlives(span, a, b, location.successor_within_block());
-            }
+        // 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).
+        if let Rvalue::Ref(region, _bk, ref borrowed_lv) = *rvalue {
+            self.add_reborrow_constraint(location, region, borrowed_lv);
         }
 
-        self.super_statement(block, statement, location);
+        self.super_rvalue(rvalue, location);
     }
 }

src/librustc_mir/transform/nll/free_regions.rs

@@ -50,6 +50,9 @@ pub fn free_regions<'a, 'gcx, 'tcx>(
 
     let mut indices = FxHashMap();
 
+    // `'static` is always free.
+    insert_free_region(&mut indices, infcx.tcx.types.re_static);
+
     // Extract the early regions.
     let item_substs = Substs::identity_for_item(infcx.tcx, item_def_id);
     for item_subst in item_substs {

src/librustc_mir/transform/nll/mod.rs

@@ -15,14 +15,15 @@ use rustc::ty::{self, RegionKind, RegionVid};
 use rustc::util::nodemap::FxHashMap;
 use std::collections::BTreeSet;
 use transform::MirSource;
+use transform::type_check;
 use util::liveness::{self, LivenessMode, LivenessResult, LocalSet};
 
 use util as mir_util;
 use self::mir_util::PassWhere;
 
 mod constraint_generation;
+mod subtype_constraint_generation;
 mod free_regions;
-mod subtype;
 
 pub(crate) mod region_infer;
 use self::region_infer::RegionInferenceContext;
@@ -35,6 +36,7 @@ mod renumber;
 pub fn compute_regions<'a, 'gcx, 'tcx>(
     infcx: &InferCtxt<'a, 'gcx, 'tcx>,
     def_id: DefId,
+    param_env: ty::ParamEnv<'gcx>,
     mir: &mut Mir<'tcx>,
 ) -> RegionInferenceContext<'tcx> {
     // Compute named region information.
@@ -43,6 +45,16 @@ pub fn compute_regions<'a, 'gcx, 'tcx>(
     // Replace all regions with fresh inference variables.
     renumber::renumber_mir(infcx, free_regions, mir);
 
+    // Run the MIR type-checker.
+    let mir_node_id = infcx.tcx.hir.as_local_node_id(def_id).unwrap();
+    let constraint_sets = &type_check::type_check(infcx, mir_node_id, param_env, mir);
+
+    // Create the region inference context, taking ownership of the region inference
+    // data that was contained in `infcx`.
+    let var_origins = infcx.take_region_var_origins();
+    let mut regioncx = RegionInferenceContext::new(var_origins, free_regions, mir);
+    subtype_constraint_generation::generate(&mut regioncx, free_regions, mir, constraint_sets);
+
     // Compute what is live where.
     let liveness = &LivenessResults {
         regular: liveness::liveness_of_locals(
@@ -62,12 +74,10 @@ pub fn compute_regions<'a, 'gcx, 'tcx>(
         ),
     };
 
-    // Create the region inference context, generate the constraints,
-    // and then solve them.
-    let var_origins = infcx.take_region_var_origins();
-    let mut regioncx = RegionInferenceContext::new(var_origins, free_regions, mir);
-    let param_env = infcx.tcx.param_env(def_id);
+    // Generate non-subtyping constraints.
     constraint_generation::generate_constraints(infcx, &mut regioncx, &mir, param_env, liveness);
+
+    // Solve the region constraints.
     regioncx.solve(infcx, &mir);
 
     // Dump MIR results into a file, if that is enabled. This let us
@@ -123,12 +133,7 @@ fn dump_mir_results<'a, 'gcx, 'tcx>(
         match pass_where {
             // Before the CFG, dump out the values for each region variable.
             PassWhere::BeforeCFG => for region in regioncx.regions() {
-                writeln!(
-                    out,
-                    "| {:?}: {:?}",
-                    region,
-                    regioncx.region_value(region)
-                )?;
+                writeln!(out, "| {:?}: {:?}", region, regioncx.region_value(region))?;
             },
 
             // Before each basic block, dump out the values

src/librustc_mir/transform/nll/region_infer.rs

@@ -183,6 +183,15 @@ impl<'a, 'gcx, 'tcx> RegionInferenceContext<'tcx> {
             // Add `end(X)` into the set for X.
             self.definitions[variable].value.add_free_region(variable);
 
+            // `'static` outlives all other free regions as well.
+            if let ty::ReStatic = free_region {
+                for &other_variable in indices.values() {
+                    self.definitions[variable]
+                        .value
+                        .add_free_region(other_variable);
+                }
+            }
+
             // Go through each region Y that outlives X (i.e., where
             // Y: X is true). Add `end(X)` into the set for `Y`.
             for superregion in free_region_map.regions_that_outlive(&free_region) {