NLL feature complete (adds feature(nll))!

src/librustc/infer/mod.rs

@@ -48,6 +48,7 @@ use self::outlives::env::OutlivesEnvironment;
 use self::type_variable::TypeVariableOrigin;
 use self::unify_key::ToType;
 
+pub mod anon_types;
 pub mod at;
 mod combine;
 mod equate;

src/librustc/infer/outlives/free_region_map.rs

@@ -38,20 +38,6 @@ impl<'tcx> FreeRegionMap<'tcx> {
         }
     }
 
-    /// Tests whether `r_a <= r_b`. Both must be free regions or
-    /// `'static`.
-    pub fn sub_free_regions<'a, 'gcx>(&self,
-                                      r_a: Region<'tcx>,
-                                      r_b: Region<'tcx>)
-                                      -> bool {
-        assert!(is_free_or_static(r_a) && is_free_or_static(r_b));
-        if let ty::ReStatic = r_b {
-            true // `'a <= 'static` is just always true, and not stored in the relation explicitly
-        } else {
-            r_a == r_b || self.relation.contains(&r_a, &r_b)
-        }
-    }
-
     /// Compute the least-upper-bound of two free regions. In some
     /// cases, this is more conservative than necessary, in order to
     /// avoid making arbitrary choices. See
@@ -75,6 +61,29 @@ impl<'tcx> FreeRegionMap<'tcx> {
     }
 }
 
+/// The NLL region handling code represents free region relations in a
+/// slightly different way; this trait allows functions to be abstract
+/// over which version is in use.
+pub trait FreeRegionRelations<'tcx> {
+    /// Tests whether `r_a <= r_b`. Both must be free regions or
+    /// `'static`.
+    fn sub_free_regions(&self, shorter: ty::Region<'tcx>, longer: ty::Region<'tcx>) -> bool;
+}
+
+impl<'tcx> FreeRegionRelations<'tcx> for FreeRegionMap<'tcx> {
+    fn sub_free_regions(&self,
+                        r_a: Region<'tcx>,
+                        r_b: Region<'tcx>)
+                        -> bool {
+        assert!(is_free_or_static(r_a) && is_free_or_static(r_b));
+        if let ty::ReStatic = r_b {
+            true // `'a <= 'static` is just always true, and not stored in the relation explicitly
+        } else {
+            r_a == r_b || self.relation.contains(&r_a, &r_b)
+        }
+    }
+}
+
 fn is_free(r: Region) -> bool {
     match *r {
         ty::ReEarlyBound(_) | ty::ReFree(_) => true,

src/librustc/middle/free_region.rs

@@ -15,7 +15,7 @@
 //! `TransitiveRelation` type and use that to decide when one free
 //! region outlives another and so forth.
 
-use infer::outlives::free_region_map::FreeRegionMap;
+use infer::outlives::free_region_map::{FreeRegionMap, FreeRegionRelations};
 use hir::def_id::DefId;
 use middle::region;
 use ty::{self, TyCtxt, Region};

src/librustc/session/config.rs

@@ -1190,6 +1190,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
         "choose which RELRO level to use"),
     nll: bool = (false, parse_bool, [UNTRACKED],
                  "run the non-lexical lifetimes MIR pass"),
+    nll_dump_cause: bool = (false, parse_bool, [UNTRACKED],
+                 "dump cause information when reporting errors from NLL"),
     trans_time_graph: bool = (false, parse_bool, [UNTRACKED],
         "generate a graphical HTML report of time spent in trans and LLVM"),
     thinlto: Option<bool> = (None, parse_opt_bool, [TRACKED],

src/librustc/util/ppaux.rs

@@ -865,13 +865,17 @@ impl fmt::Debug for ty::RegionVid {
 define_print! {
     () ty::InferTy, (self, f, cx) {
         display {
-            match *self {
-                ty::TyVar(_) => write!(f, "_"),
-                ty::IntVar(_) => write!(f, "{}", "{integer}"),
-                ty::FloatVar(_) => write!(f, "{}", "{float}"),
-                ty::FreshTy(v) => write!(f, "FreshTy({})", v),
-                ty::FreshIntTy(v) => write!(f, "FreshIntTy({})", v),
-                ty::FreshFloatTy(v) => write!(f, "FreshFloatTy({})", v)
+            if cx.is_verbose {
+                print!(f, cx, print_debug(self))
+            } else {
+                match *self {
+                    ty::TyVar(_) => write!(f, "_"),
+                    ty::IntVar(_) => write!(f, "{}", "{integer}"),
+                    ty::FloatVar(_) => write!(f, "{}", "{float}"),
+                    ty::FreshTy(v) => write!(f, "FreshTy({})", v),
+                    ty::FreshIntTy(v) => write!(f, "FreshIntTy({})", v),
+                    ty::FreshFloatTy(v) => write!(f, "FreshFloatTy({})", v)
+                }
             }
         }
         debug {

src/librustc_mir/borrow_check/error_reporting.rs

@@ -14,6 +14,7 @@ use rustc::mir::{BorrowKind, Field, Local, Location, Operand};
 use rustc::mir::{Place, ProjectionElem, Rvalue, Statement, StatementKind};
 use rustc::ty::{self, RegionKind};
 use rustc_data_structures::indexed_vec::Idx;
+use rustc_errors::DiagnosticBuilder;
 
 use std::rc::Rc;
 
@@ -88,7 +89,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
 
     pub(super) fn report_move_out_while_borrowed(
         &mut self,
-        _context: Context,
+        context: Context,
         (place, span): (&Place<'tcx>, Span),
         borrow: &BorrowData<'tcx>,
     ) {
@@ -100,23 +101,23 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             Some(name) => format!("`{}`", name),
             None => "value".to_owned(),
         };
-        self.tcx
-            .cannot_move_when_borrowed(
-                span,
-                &self.describe_place(place).unwrap_or("_".to_owned()),
-                Origin::Mir,
-            )
-            .span_label(
-                self.retrieve_borrow_span(borrow),
-                format!("borrow of {} occurs here", borrow_msg),
-            )
-            .span_label(span, format!("move out of {} occurs here", value_msg))
-            .emit();
+        let mut err = self.tcx.cannot_move_when_borrowed(
+            span,
+            &self.describe_place(place).unwrap_or("_".to_owned()),
+            Origin::Mir,
+        );
+        err.span_label(
+            self.retrieve_borrow_span(borrow),
+            format!("borrow of {} occurs here", borrow_msg),
+        );
+        err.span_label(span, format!("move out of {} occurs here", value_msg));
+        self.explain_why_borrow_contains_point(context, borrow, &mut err);
+        err.emit();
     }
 
     pub(super) fn report_use_while_mutably_borrowed(
         &mut self,
-        _context: Context,
+        context: Context,
         (place, span): (&Place<'tcx>, Span),
         borrow: &BorrowData<'tcx>,
     ) {
@@ -128,9 +129,24 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             Origin::Mir,
         );
 
+        self.explain_why_borrow_contains_point(context, borrow, &mut err);
+
         err.emit();
     }
 
+    fn explain_why_borrow_contains_point(
+        &self,
+        context: Context,
+        borrow: &BorrowData<'_>,
+        err: &mut DiagnosticBuilder<'_>,
+    ) {
+        if let Some(regioncx) = &self.nonlexical_regioncx {
+            if let Some(cause) = regioncx.why_region_contains_point(borrow.region, context.loc) {
+                cause.label_diagnostic(self.mir, err);
+            }
+        }
+    }
+
     /// Finds the span of arguments of a closure (within `maybe_closure_span`) and its usage of
     /// the local assigned at `location`.
     /// This is done by searching in statements succeeding `location`
@@ -313,12 +329,14 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             );
         }
 
+        self.explain_why_borrow_contains_point(context, issued_borrow, &mut err);
+
         err.emit();
     }
 
     pub(super) fn report_borrowed_value_does_not_live_long_enough(
         &mut self,
-        _: Context,
+        context: Context,
         borrow: &BorrowData<'tcx>,
         drop_span: Span,
         borrows: &ActiveBorrows<'cx, 'gcx, 'tcx>
@@ -357,27 +375,57 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         match (borrow.region, &self.describe_place(&borrow.borrowed_place)) {
             (RegionKind::ReScope(_), Some(name)) => {
                 self.report_scoped_local_value_does_not_live_long_enough(
-                    name, &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
+                    context,
+                    name,
+                    &scope_tree,
+                    &borrow,
+                    drop_span,
+                    borrow_span,
+                    proper_span,
+                    end_span
+                );
             },
             (RegionKind::ReScope(_), None) => {
                 self.report_scoped_temporary_value_does_not_live_long_enough(
-                    &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
+                    context,
+                    &scope_tree,
+                    &borrow,
+                    drop_span,
+                    borrow_span,
+                    proper_span,
+                    end_span
+                );
             },
             (RegionKind::ReEarlyBound(_), Some(name)) |
             (RegionKind::ReFree(_), Some(name)) |
             (RegionKind::ReStatic, Some(name)) |
             (RegionKind::ReEmpty, Some(name)) |
             (RegionKind::ReVar(_), Some(name)) => {
                 self.report_unscoped_local_value_does_not_live_long_enough(
-                    name, &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
+                    context,
+                    name,
+                    &scope_tree,
+                    &borrow,
+                    drop_span,
+                    borrow_span,
+                    proper_span,
+                    end_span,
+                );
             },
             (RegionKind::ReEarlyBound(_), None) |
             (RegionKind::ReFree(_), None) |
             (RegionKind::ReStatic, None) |
             (RegionKind::ReEmpty, None) |
             (RegionKind::ReVar(_), None) => {
                 self.report_unscoped_temporary_value_does_not_live_long_enough(
-                    &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
+                    context,
+                    &scope_tree,
+                    &borrow,
+                    drop_span,
+                    borrow_span,
+                    proper_span,
+                    end_span,
+                );
             },
             (RegionKind::ReLateBound(_, _), _) |
             (RegionKind::ReSkolemized(_, _), _) |
@@ -389,8 +437,15 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
     }
 
     fn report_scoped_local_value_does_not_live_long_enough(
-        &mut self, name: &String, _scope_tree: &Rc<ScopeTree>, _borrow: &BorrowData<'tcx>,
-        drop_span: Span, borrow_span: Span, _proper_span: Span, end_span: Option<Span>
+        &mut self,
+        context: Context,
+        name: &String,
+        _scope_tree: &Rc<ScopeTree>,
+        borrow: &BorrowData<'tcx>,
+        drop_span: Span,
+        borrow_span: Span,
+        _proper_span: Span,
+        end_span: Option<Span>,
     ) {
         let mut err = self.tcx.path_does_not_live_long_enough(borrow_span,
                                                               &format!("`{}`", name),
@@ -400,12 +455,19 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         if let Some(end) = end_span {
             err.span_label(end, "borrowed value needs to live until here");
         }
+        self.explain_why_borrow_contains_point(context, borrow, &mut err);
         err.emit();
     }
 
     fn report_scoped_temporary_value_does_not_live_long_enough(
-        &mut self, _scope_tree: &Rc<ScopeTree>, _borrow: &BorrowData<'tcx>,
-        drop_span: Span, _borrow_span: Span, proper_span: Span, end_span: Option<Span>
+        &mut self,
+        context: Context,
+        _scope_tree: &Rc<ScopeTree>,
+        borrow: &BorrowData<'tcx>,
+        drop_span: Span,
+        _borrow_span: Span,
+        proper_span: Span,
+        end_span: Option<Span>,
     ) {
         let mut err = self.tcx.path_does_not_live_long_enough(proper_span,
                                                               "borrowed value",
@@ -416,12 +478,20 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         if let Some(end) = end_span {
             err.span_label(end, "temporary value needs to live until here");
         }
+        self.explain_why_borrow_contains_point(context, borrow, &mut err);
         err.emit();
     }
 
     fn report_unscoped_local_value_does_not_live_long_enough(
-        &mut self, name: &String, scope_tree: &Rc<ScopeTree>, borrow: &BorrowData<'tcx>,
-        drop_span: Span, borrow_span: Span, _proper_span: Span, _end_span: Option<Span>
+        &mut self,
+        context: Context,
+        name: &String,
+        scope_tree: &Rc<ScopeTree>,
+        borrow: &BorrowData<'tcx>,
+        drop_span: Span,
+        borrow_span: Span,
+        _proper_span: Span,
+        _end_span: Option<Span>,
     ) {
         let mut err = self.tcx.path_does_not_live_long_enough(borrow_span,
                                                               &format!("`{}`", name),
@@ -431,12 +501,19 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         self.tcx.note_and_explain_region(scope_tree, &mut err,
                                          "borrowed value must be valid for ",
                                          borrow.region, "...");
+        self.explain_why_borrow_contains_point(context, borrow, &mut err);
         err.emit();
     }
 
     fn report_unscoped_temporary_value_does_not_live_long_enough(
-        &mut self, scope_tree: &Rc<ScopeTree>, borrow: &BorrowData<'tcx>,
-        drop_span: Span, _borrow_span: Span, proper_span: Span, _end_span: Option<Span>
+        &mut self,
+        context: Context,
+        scope_tree: &Rc<ScopeTree>,
+        borrow: &BorrowData<'tcx>,
+        drop_span: Span,
+        _borrow_span: Span,
+        proper_span: Span,
+        _end_span: Option<Span>
     ) {
         let mut err = self.tcx.path_does_not_live_long_enough(proper_span,
                                                               "borrowed value",
@@ -446,12 +523,13 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         self.tcx.note_and_explain_region(scope_tree, &mut err,
                                          "borrowed value must be valid for ",
                                          borrow.region, "...");
+        self.explain_why_borrow_contains_point(context, borrow, &mut err);
         err.emit();
     }
 
     pub(super) fn report_illegal_mutation_of_borrowed(
         &mut self,
-        _: Context,
+        context: Context,
         (place, span): (&Place<'tcx>, Span),
         loan: &BorrowData,
     ) {
@@ -462,6 +540,8 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             Origin::Mir,
         );
 
+        self.explain_why_borrow_contains_point(context, loan, &mut err);
+
         err.emit();
     }