Non-lexical lifetimes region renumberer

src/librustc_mir/transform/nll.rs

@@ -8,26 +8,91 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rustc::ty::TyCtxt;
-use rustc::mir::Mir;
-use rustc::mir::visit::MutVisitor;
+use rustc::ty::TypeFoldable;
+use rustc::ty::subst::Substs;
+use rustc::ty::{Ty, TyCtxt, ClosureSubsts};
+use rustc::mir::{Mir, Location, Rvalue, BasicBlock, Statement, StatementKind};
+use rustc::mir::visit::{MutVisitor, Lookup};
 use rustc::mir::transform::{MirPass, MirSource};
+use rustc::infer::{self, InferCtxt};
+use syntax_pos::Span;
 
 #[allow(dead_code)]
-struct NLLVisitor<'a, 'tcx: 'a> {
-    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+struct NLLVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
+    infcx: InferCtxt<'a, 'gcx, 'tcx>,
+    source: &'a Mir<'tcx>
 }
 
-impl<'a, 'tcx> NLLVisitor<'a, 'tcx> {
-    pub fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
+impl<'a, 'gcx, 'tcx> NLLVisitor<'a, 'gcx, 'tcx> {
+    pub fn new(infcx: InferCtxt<'a, 'gcx, 'tcx>, source: &'a Mir<'tcx>) -> Self {
         NLLVisitor {
-            tcx: tcx
+            infcx: infcx,
+            source: source,
         }
     }
+
+    fn renumber_regions<T>(&self, value: &T, span: Span) -> T where T: TypeFoldable<'tcx> {
+        self.infcx.tcx.fold_regions(value, &mut false, |_region, _depth| {
+            self.infcx.next_region_var(infer::MiscVariable(span))
+        })
+    }
 }
 
-impl<'a, 'tcx> MutVisitor<'tcx> for NLLVisitor<'a, 'tcx> {
-    // FIXME: Nashenas88: implement me!
+fn span_from_location<'tcx>(source: &Mir<'tcx>, location: Location) -> Span {
+    source[location.block].statements[location.statement_index].source_info.span
+}
+
+impl<'a, 'gcx, 'tcx> MutVisitor<'tcx> for NLLVisitor<'a, 'gcx, 'tcx> {
+    fn visit_ty(&mut self, ty: &mut Ty<'tcx>, lookup: Lookup) {
+        let old_ty = *ty;
+        let span = match lookup {
+            Lookup::Loc(location) => span_from_location(self.source, location),
+            Lookup::Src(source_info) => source_info.span,
+        };
+        *ty = self.renumber_regions(&old_ty, span);
+    }
+
+    fn visit_substs(&mut self, substs: &mut &'tcx Substs<'tcx>, location: Location) {
+        *substs = self.renumber_regions(&{*substs}, span_from_location(self.source, location));
+    }
+
+    fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>, location: Location) {
+        match *rvalue {
+            Rvalue::Ref(ref mut r, _, _) => {
+                let old_r = *r;
+                *r = self.renumber_regions(&old_r, span_from_location(self.source, location));
+            }
+            Rvalue::Use(..) |
+            Rvalue::Repeat(..) |
+            Rvalue::Len(..) |
+            Rvalue::Cast(..) |
+            Rvalue::BinaryOp(..) |
+            Rvalue::CheckedBinaryOp(..) |
+            Rvalue::UnaryOp(..) |
+            Rvalue::Discriminant(..) |
+            Rvalue::NullaryOp(..) |
+            Rvalue::Aggregate(..) => {
+                // These variants don't contain regions.
+            }
+        }
+        self.super_rvalue(rvalue, location);
+    }
+
+    fn visit_closure_substs(&mut self,
+                            substs: &mut ClosureSubsts<'tcx>,
+                            location: Location) {
+        *substs = self.renumber_regions(substs, span_from_location(self.source, location));
+    }
+
+    fn visit_statement(&mut self,
+                       block: BasicBlock,
+                       statement: &mut Statement<'tcx>,
+                       location: Location) {
+        if let StatementKind::EndRegion(_) = statement.kind {
+            statement.kind = StatementKind::Nop;
+        }
+        self.super_statement(block, statement, location);
+    }
 }
 
 // MIR Pass for non-lexical lifetimes
@@ -38,10 +103,20 @@ impl MirPass for NLL {
                           tcx: TyCtxt<'a, 'tcx, 'tcx>,
                           _: MirSource,
                           mir: &mut Mir<'tcx>) {
-        if tcx.sess.opts.debugging_opts.nll {
+        if !tcx.sess.opts.debugging_opts.nll {
+            return;
+        }
+
+        tcx.infer_ctxt().enter(|infcx| {
             // Clone mir so we can mutate it without disturbing the rest
             // of the compiler
-            NLLVisitor::new(tcx).visit_mir(&mut mir.clone());
-        }
+            let mut renumbered_mir = mir.clone();
+
+            // Note that we're using the passed-in mir for the visitor. This is
+            // so we can lookup locations during traversal without worrying about
+            // maintaing both a mutable and immutable reference to the same object
+            let mut visitor = NLLVisitor::new(infcx, &mir);
+            visitor.visit_mir(&mut renumbered_mir);
+        })
     }
 }