Refactored and tidied up report function

src/librustc_mir/borrow_check/error_reporting.rs

@@ -9,11 +9,14 @@
 // except according to those terms.
 
 use syntax_pos::Span;
+use rustc::middle::region::ScopeTree;
 use rustc::mir::{BorrowKind, Field, Local, Location, Operand};
 use rustc::mir::{Place, ProjectionElem, Rvalue, StatementKind};
 use rustc::ty::{self, RegionKind};
 use rustc_data_structures::indexed_vec::Idx;
 
+use std::rc::Rc;
+
 use super::{MirBorrowckCtxt, Context};
 use super::{InitializationRequiringAction, PrefixSet};
 use dataflow::{BorrowData, Borrows, FlowAtLocation, MovingOutStatements};
@@ -354,64 +357,100 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
             _ => drop_span,
         };
 
-        match &self.describe_place(&borrow.place) {
+        match (borrow.region, &self.describe_place(&borrow.place)) {
-            Some(description) => {
+            (RegionKind::ReScope(_), Some(name)) => {
-                match borrow.region {
+                self.report_scoped_local_value_does_not_live_long_enough(
-                    RegionKind::ReScope(_) => {
+                    name, &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
-                        let mut err = self.tcx.path_does_not_live_long_enough(
-                            drop_span, &format!("`{}`", description), Origin::Mir);
-                        err.span_label(borrow_span, "borrow occurs here");
-                        err.span_label(drop_span,
-                                       format!("`{}` dropped here while still borrowed",
-                                               description));
-                        if let Some(end) = end_span {
-                            err.span_label(end, "borrowed value needs to live until here");
-                        }
-                        err.emit();
-                    },
-                    _ => {
-                        let mut err = self.tcx.path_does_not_live_long_enough(
-                            borrow_span, &format!("`{}`", description), Origin::Mir);
-                        err.span_label(borrow_span, "does not live long enough");
-                        err.span_label(drop_span, "borrowed value only lives until here");
-                        self.tcx.note_and_explain_region(scope_tree, &mut err,
-                                                         "borrowed value must be valid for ",
-                                                         borrow.region, "...");
-                        err.emit();
-                    }
-                }
             },
-            None => {
+            (RegionKind::ReScope(_), None) => {
-                match borrow.region {
+                self.report_scoped_temporary_value_does_not_live_long_enough(
-                    RegionKind::ReEarlyBound(_) | RegionKind::ReFree(_) => {
+                    &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
-                        let mut err = self.tcx.path_does_not_live_long_enough(proper_span,
+            },
-                                                                              "borrowed value",
+            (RegionKind::ReEarlyBound(_), Some(name)) |
-                                                                              Origin::Mir);
+            (RegionKind::ReFree(_), Some(name)) |
-                        err.span_label(proper_span, "does not live long enough");
+            (RegionKind::ReStatic, Some(name)) |
-                        err.span_label(drop_span, "temporary value only lives until here");
+            (RegionKind::ReEmpty, Some(name)) |
-                        self.tcx.note_and_explain_region(scope_tree, &mut err,
+            (RegionKind::ReVar(_), Some(name)) => {
-                                                         "borrowed value must be valid for ",
+                self.report_unscoped_local_value_does_not_live_long_enough(
-                                                         borrow.region, "...");
+                    name, &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
-                        err.emit();
+            },
-                    },
+            (RegionKind::ReEarlyBound(_), None) |
-                    _ => {
+            (RegionKind::ReFree(_), None) |
-                        let mut err = self.tcx.path_does_not_live_long_enough(drop_span,
+            (RegionKind::ReStatic, None) |
-                                                                              "borrowed value",
+            (RegionKind::ReEmpty, None) |
-                                                                              Origin::Mir);
+            (RegionKind::ReVar(_), None) => {
-                        err.span_label(proper_span, "temporary value created here");
+                self.report_unscoped_temporary_value_does_not_live_long_enough(
-                        err.span_label(drop_span,
+                    &scope_tree, &borrow, drop_span, borrow_span, proper_span, end_span);
-                                       "temporary value dropped here while still borrowed");
+            },
-                        err.note("consider using a `let` binding to increase its lifetime");
+            (RegionKind::ReLateBound(_, _), _) |
-                        if let Some(end) = end_span {
+            (RegionKind::ReSkolemized(_, _), _) |
-                            err.span_label(end, "temporary value needs to live until here");
+            (RegionKind::ReErased, _) => {
-                        }
+                span_bug!(drop_span, "region does not make sense in this context");
-                        err.emit();
-                    },
-                }
             },
         }
     }
 
+    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>
+    ) {
+        let mut err = self.tcx.path_does_not_live_long_enough(drop_span,
+                                                              &format!("`{}`", name),
+                                                              Origin::Mir);
+        err.span_label(borrow_span, "borrow occurs here");
+        err.span_label(drop_span, format!("`{}` dropped here while still borrowed", name));
+        if let Some(end) = end_span {
+            err.span_label(end, "borrowed value needs to live until here");
+        }
+        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>
+    ) {
+        let mut err = self.tcx.path_does_not_live_long_enough(borrow_span,
+                                                              "borrowed value",
+                                                              Origin::Mir);
+        err.span_label(proper_span, "temporary value created here");
+        err.span_label(drop_span, "temporary value dropped here while still borrowed");
+        err.note("consider using a `let` binding to increase its lifetime");
+        if let Some(end) = end_span {
+            err.span_label(end, "temporary value needs to live until here");
+        }
+        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>
+    ) {
+        let mut err = self.tcx.path_does_not_live_long_enough(borrow_span,
+                                                              &format!("`{}`", name),
+                                                              Origin::Mir);
+        err.span_label(borrow_span, "does not live long enough");
+        err.span_label(drop_span, "borrowed value only lives until here");
+        self.tcx.note_and_explain_region(scope_tree, &mut err,
+                                         "borrowed value must be valid for ",
+                                         borrow.region, "...");
+        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>
+    ) {
+        let mut err = self.tcx.path_does_not_live_long_enough(proper_span,
+                                                              "borrowed value",
+                                                              Origin::Mir);
+        err.span_label(proper_span, "does not live long enough");
+        err.span_label(drop_span, "temporary value only lives until here");
+        self.tcx.note_and_explain_region(scope_tree, &mut err,
+                                         "borrowed value must be valid for ",
+                                         borrow.region, "...");
+        err.emit();
+    }
+
     pub(super) fn report_illegal_mutation_of_borrowed(
         &mut self,
         _: Context,