diff options
Diffstat (limited to 'src/librustc_mir/util/borrowck_errors.rs')
| -rw-r--r-- | src/librustc_mir/util/borrowck_errors.rs | 820 |
1 files changed, 509 insertions, 311 deletions
diff --git a/src/librustc_mir/util/borrowck_errors.rs b/src/librustc_mir/util/borrowck_errors.rs index 4a7ee397aec..7be6241b3f9 100644 --- a/src/librustc_mir/util/borrowck_errors.rs +++ b/src/librustc_mir/util/borrowck_errors.rs @@ -8,15 +8,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use rustc::ty::{self, TyCtxt}; use rustc::session::config::BorrowckMode; +use rustc::ty::{self, TyCtxt}; use rustc_errors::{DiagnosticBuilder, DiagnosticId}; use syntax_pos::{MultiSpan, Span}; use std::fmt; #[derive(Copy, Clone, PartialEq, Eq, Debug)] -pub enum Origin { Ast, Mir } +pub enum Origin { + Ast, + Mir, +} impl fmt::Display for Origin { fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { @@ -52,95 +55,131 @@ impl Origin { } } -pub trait BorrowckErrors { - fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(&'a self, - sp: S, - msg: &str, - code: DiagnosticId) - -> DiagnosticBuilder<'a>; +pub trait BorrowckErrors<'cx>: Sized + Copy { + fn struct_span_err_with_code<S: Into<MultiSpan>>( + self, + sp: S, + msg: &str, + code: DiagnosticId, + ) -> DiagnosticBuilder<'cx>; - fn struct_span_err<'a, S: Into<MultiSpan>>(&'a self, - sp: S, - msg: &str) - -> DiagnosticBuilder<'a>; + fn struct_span_err<S: Into<MultiSpan>>(self, sp: S, msg: &str) -> DiagnosticBuilder<'cx>; /// Cancels the given error if we shouldn't emit errors for a given /// origin in the current mode. /// /// Always make sure that the error gets passed through this function /// before you return it. - fn cancel_if_wrong_origin<'a>(&'a self, - diag: DiagnosticBuilder<'a>, - o: Origin) - -> DiagnosticBuilder<'a>; - - fn cannot_move_when_borrowed(&self, span: Span, desc: &str, o: Origin) - -> DiagnosticBuilder<'_> - { - let err = struct_span_err!(self, span, E0505, - "cannot move out of `{}` because it is borrowed{OGN}", - desc, OGN=o); + fn cancel_if_wrong_origin( + self, + diag: DiagnosticBuilder<'cx>, + o: Origin, + ) -> DiagnosticBuilder<'cx>; + + fn cannot_move_when_borrowed( + self, + span: Span, + desc: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0505, + "cannot move out of `{}` because it is borrowed{OGN}", + desc, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_use_when_mutably_borrowed(&self, - span: Span, - desc: &str, - borrow_span: Span, - borrow_desc: &str, - o: Origin) - -> DiagnosticBuilder<'_> - { - let mut err = struct_span_err!(self, span, E0503, - "cannot use `{}` because it was mutably borrowed{OGN}", - desc, OGN=o); + fn cannot_use_when_mutably_borrowed( + self, + span: Span, + desc: &str, + borrow_span: Span, + borrow_desc: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + span, + E0503, + "cannot use `{}` because it was mutably borrowed{OGN}", + desc, + OGN = o + ); - err.span_label(borrow_span, format!("borrow of `{}` occurs here", borrow_desc)); + err.span_label( + borrow_span, + format!("borrow of `{}` occurs here", borrow_desc), + ); err.span_label(span, format!("use of borrowed `{}`", borrow_desc)); self.cancel_if_wrong_origin(err, o) } - fn cannot_act_on_uninitialized_variable(&self, - span: Span, - verb: &str, - desc: &str, - o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, span, E0381, - "{} of possibly uninitialized variable: `{}`{OGN}", - verb, desc, OGN=o); + fn cannot_act_on_uninitialized_variable( + self, + span: Span, + verb: &str, + desc: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0381, + "{} of possibly uninitialized variable: `{}`{OGN}", + verb, + desc, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_mutably_borrow_multiply(&self, - new_loan_span: Span, - desc: &str, - opt_via: &str, - old_loan_span: Span, - old_opt_via: &str, - old_load_end_span: Option<Span>, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, new_loan_span, E0499, - "cannot borrow `{}`{} as mutable more than once at a time{OGN}", - desc, opt_via, OGN=o); + fn cannot_mutably_borrow_multiply( + self, + new_loan_span: Span, + desc: &str, + opt_via: &str, + old_loan_span: Span, + old_opt_via: &str, + old_load_end_span: Option<Span>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + new_loan_span, + E0499, + "cannot borrow `{}`{} as mutable more than once at a time{OGN}", + desc, + opt_via, + OGN = o + ); if old_loan_span == new_loan_span { // Both borrows are happening in the same place // Meaning the borrow is occurring in a loop - err.span_label(new_loan_span, - format!("mutable borrow starts here in previous \ - iteration of loop{}", opt_via)); + err.span_label( + new_loan_span, + format!( + "mutable borrow starts here in previous \ + iteration of loop{}", + opt_via + ), + ); if let Some(old_load_end_span) = old_load_end_span { err.span_label(old_load_end_span, "mutable borrow ends here"); } } else { - err.span_label(old_loan_span, - format!("first mutable borrow occurs here{}", old_opt_via)); - err.span_label(new_loan_span, - format!("second mutable borrow occurs here{}", opt_via)); + err.span_label( + old_loan_span, + format!("first mutable borrow occurs here{}", old_opt_via), + ); + err.span_label( + new_loan_span, + format!("second mutable borrow occurs here{}", opt_via), + ); if let Some(old_load_end_span) = old_load_end_span { err.span_label(old_load_end_span, "first borrow ends here"); } @@ -148,373 +187,532 @@ pub trait BorrowckErrors { self.cancel_if_wrong_origin(err, o) } - fn cannot_uniquely_borrow_by_two_closures(&self, - new_loan_span: Span, - desc: &str, - old_loan_span: Span, - old_load_end_span: Option<Span>, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, new_loan_span, E0524, - "two closures require unique access to `{}` at the same time{OGN}", - desc, OGN=o); - err.span_label( - old_loan_span, - "first closure is constructed here"); - err.span_label( + fn cannot_uniquely_borrow_by_two_closures( + self, + new_loan_span: Span, + desc: &str, + old_loan_span: Span, + old_load_end_span: Option<Span>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, new_loan_span, - "second closure is constructed here"); - if let Some(old_load_end_span) = old_load_end_span { + E0524, + "two closures require unique access to `{}` at the same time{OGN}", + desc, + OGN = o + ); + if old_loan_span == new_loan_span { err.span_label( - old_load_end_span, - "borrow from first closure ends here"); + old_loan_span, + "closures are constructed here in different iterations of loop" + ); + } else { + err.span_label(old_loan_span, "first closure is constructed here"); + err.span_label(new_loan_span, "second closure is constructed here"); + } + if let Some(old_load_end_span) = old_load_end_span { + err.span_label(old_load_end_span, "borrow from first closure ends here"); } self.cancel_if_wrong_origin(err, o) } - fn cannot_uniquely_borrow_by_one_closure(&self, - new_loan_span: Span, - desc_new: &str, - opt_via: &str, - old_loan_span: Span, - noun_old: &str, - old_opt_via: &str, - previous_end_span: Option<Span>, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, new_loan_span, E0500, - "closure requires unique access to `{}` but {} is already borrowed{}{OGN}", - desc_new, noun_old, old_opt_via, OGN=o); - err.span_label(new_loan_span, - format!("closure construction occurs here{}", opt_via)); - err.span_label(old_loan_span, - format!("borrow occurs here{}", old_opt_via)); + fn cannot_uniquely_borrow_by_one_closure( + self, + new_loan_span: Span, + desc_new: &str, + opt_via: &str, + old_loan_span: Span, + noun_old: &str, + old_opt_via: &str, + previous_end_span: Option<Span>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + new_loan_span, + E0500, + "closure requires unique access to `{}` but {} is already borrowed{}{OGN}", + desc_new, + noun_old, + old_opt_via, + OGN = o + ); + err.span_label( + new_loan_span, + format!("closure construction occurs here{}", opt_via), + ); + err.span_label(old_loan_span, format!("borrow occurs here{}", old_opt_via)); if let Some(previous_end_span) = previous_end_span { err.span_label(previous_end_span, "borrow ends here"); } self.cancel_if_wrong_origin(err, o) } - fn cannot_reborrow_already_uniquely_borrowed(&self, - new_loan_span: Span, - desc_new: &str, - opt_via: &str, - kind_new: &str, - old_loan_span: Span, - old_opt_via: &str, - previous_end_span: Option<Span>, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, new_loan_span, E0501, - "cannot borrow `{}`{} as {} because previous closure \ - requires unique access{OGN}", - desc_new, opt_via, kind_new, OGN=o); - err.span_label(new_loan_span, - format!("borrow occurs here{}", opt_via)); - err.span_label(old_loan_span, - format!("closure construction occurs here{}", old_opt_via)); + fn cannot_reborrow_already_uniquely_borrowed( + self, + new_loan_span: Span, + desc_new: &str, + opt_via: &str, + kind_new: &str, + old_loan_span: Span, + old_opt_via: &str, + previous_end_span: Option<Span>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + new_loan_span, + E0501, + "cannot borrow `{}`{} as {} because previous closure \ + requires unique access{OGN}", + desc_new, + opt_via, + kind_new, + OGN = o + ); + err.span_label(new_loan_span, format!("borrow occurs here{}", opt_via)); + err.span_label( + old_loan_span, + format!("closure construction occurs here{}", old_opt_via), + ); if let Some(previous_end_span) = previous_end_span { err.span_label(previous_end_span, "borrow from closure ends here"); } self.cancel_if_wrong_origin(err, o) } - fn cannot_reborrow_already_borrowed(&self, - span: Span, - desc_new: &str, - msg_new: &str, - kind_new: &str, - old_span: Span, - noun_old: &str, - kind_old: &str, - msg_old: &str, - old_load_end_span: Option<Span>, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, span, E0502, - "cannot borrow `{}`{} as {} because {} is also borrowed as {}{}{OGN}", - desc_new, msg_new, kind_new, noun_old, kind_old, msg_old, OGN=o); + fn cannot_reborrow_already_borrowed( + self, + span: Span, + desc_new: &str, + msg_new: &str, + kind_new: &str, + old_span: Span, + noun_old: &str, + kind_old: &str, + msg_old: &str, + old_load_end_span: Option<Span>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + span, + E0502, + "cannot borrow `{}`{} as {} because {} is also borrowed as {}{}{OGN}", + desc_new, + msg_new, + kind_new, + noun_old, + kind_old, + msg_old, + OGN = o + ); err.span_label(span, format!("{} borrow occurs here{}", kind_new, msg_new)); - err.span_label(old_span, format!("{} borrow occurs here{}", kind_old, msg_old)); + err.span_label( + old_span, + format!("{} borrow occurs here{}", kind_old, msg_old), + ); if let Some(old_load_end_span) = old_load_end_span { err.span_label(old_load_end_span, format!("{} borrow ends here", kind_old)); } self.cancel_if_wrong_origin(err, o) } - fn cannot_assign_to_borrowed(&self, span: Span, borrow_span: Span, desc: &str, o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, span, E0506, - "cannot assign to `{}` because it is borrowed{OGN}", - desc, OGN=o); + fn cannot_assign_to_borrowed( + self, + span: Span, + borrow_span: Span, + desc: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + span, + E0506, + "cannot assign to `{}` because it is borrowed{OGN}", + desc, + OGN = o + ); err.span_label(borrow_span, format!("borrow of `{}` occurs here", desc)); - err.span_label(span, format!("assignment to borrowed `{}` occurs here", desc)); + err.span_label( + span, + format!("assignment to borrowed `{}` occurs here", desc), + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_move_into_closure(&self, span: Span, desc: &str, o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, span, E0504, - "cannot move `{}` into closure because it is borrowed{OGN}", - desc, OGN=o); + fn cannot_move_into_closure(self, span: Span, desc: &str, o: Origin) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0504, + "cannot move `{}` into closure because it is borrowed{OGN}", + desc, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_reassign_immutable(&self, span: Span, desc: &str, is_arg: bool, o: Origin) - -> DiagnosticBuilder - { + fn cannot_reassign_immutable( + self, + span: Span, + desc: &str, + is_arg: bool, + o: Origin, + ) -> DiagnosticBuilder<'cx> { let msg = if is_arg { "to immutable argument" } else { "twice to immutable variable" }; - let err = struct_span_err!(self, span, E0384, - "cannot assign {} `{}`{OGN}", - msg, desc, OGN=o); + let err = struct_span_err!( + self, + span, + E0384, + "cannot assign {} `{}`{OGN}", + msg, + desc, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_assign(&self, span: Span, desc: &str, o: Origin) -> DiagnosticBuilder - { - let err = struct_span_err!(self, span, E0594, - "cannot assign to {}{OGN}", - desc, OGN=o); + fn cannot_assign(self, span: Span, desc: &str, o: Origin) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!(self, span, E0594, "cannot assign to {}{OGN}", desc, OGN = o); self.cancel_if_wrong_origin(err, o) } - fn cannot_assign_static(&self, span: Span, desc: &str, o: Origin) - -> DiagnosticBuilder - { + fn cannot_assign_static(self, span: Span, desc: &str, o: Origin) -> DiagnosticBuilder<'cx> { self.cannot_assign(span, &format!("immutable static item `{}`", desc), o) } - fn cannot_move_out_of(&self, move_from_span: Span, move_from_desc: &str, o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, move_from_span, E0507, - "cannot move out of {}{OGN}", - move_from_desc, OGN=o); + fn cannot_move_out_of( + self, + move_from_span: Span, + move_from_desc: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + move_from_span, + E0507, + "cannot move out of {}{OGN}", + move_from_desc, + OGN = o + ); err.span_label( move_from_span, - format!("cannot move out of {}", move_from_desc)); + format!("cannot move out of {}", move_from_desc), + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_move_out_of_interior_noncopy(&self, - move_from_span: Span, - ty: ty::Ty, - is_index: bool, - o: Origin) - -> DiagnosticBuilder - { + /// Signal an error due to an attempt to move out of the interior + /// of an array or slice. `is_index` is None when error origin + /// didn't capture whether there was an indexing operation or not. + fn cannot_move_out_of_interior_noncopy( + self, + move_from_span: Span, + ty: ty::Ty, + is_index: Option<bool>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { let type_name = match (&ty.sty, is_index) { - (&ty::TyArray(_, _), true) => "array", - (&ty::TySlice(_), _) => "slice", + (&ty::TyArray(_, _), Some(true)) | (&ty::TyArray(_, _), None) => "array", + (&ty::TySlice(_), _) => "slice", _ => span_bug!(move_from_span, "this path should not cause illegal move"), }; - let mut err = struct_span_err!(self, move_from_span, E0508, - "cannot move out of type `{}`, \ - a non-copy {}{OGN}", - ty, type_name, OGN=o); + let mut err = struct_span_err!( + self, + move_from_span, + E0508, + "cannot move out of type `{}`, \ + a non-copy {}{OGN}", + ty, + type_name, + OGN = o + ); err.span_label(move_from_span, "cannot move out of here"); self.cancel_if_wrong_origin(err, o) } - fn cannot_move_out_of_interior_of_drop(&self, - move_from_span: Span, - container_ty: ty::Ty, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, move_from_span, E0509, - "cannot move out of type `{}`, \ - which implements the `Drop` trait{OGN}", - container_ty, OGN=o); + fn cannot_move_out_of_interior_of_drop( + self, + move_from_span: Span, + container_ty: ty::Ty, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + move_from_span, + E0509, + "cannot move out of type `{}`, \ + which implements the `Drop` trait{OGN}", + container_ty, + OGN = o + ); err.span_label(move_from_span, "cannot move out of here"); self.cancel_if_wrong_origin(err, o) } - fn cannot_act_on_moved_value(&self, - use_span: Span, - verb: &str, - optional_adverb_for_moved: &str, - moved_path: &str, - o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, use_span, E0382, - "{} of {}moved value: `{}`{OGN}", - verb, optional_adverb_for_moved, moved_path, OGN=o); + fn cannot_act_on_moved_value( + self, + use_span: Span, + verb: &str, + optional_adverb_for_moved: &str, + moved_path: Option<String>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let moved_path = moved_path + .map(|mp| format!(": `{}`", mp)) + .unwrap_or("".to_owned()); + + let err = struct_span_err!( + self, + use_span, + E0382, + "{} of {}moved value{}{OGN}", + verb, + optional_adverb_for_moved, + moved_path, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_partially_reinit_an_uninit_struct(&self, - span: Span, - uninit_path: &str, - o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, - span, - E0383, - "partial reinitialization of uninitialized structure `{}`{OGN}", - uninit_path, OGN=o); + fn cannot_partially_reinit_an_uninit_struct( + self, + span: Span, + uninit_path: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0383, + "partial reinitialization of uninitialized structure `{}`{OGN}", + uninit_path, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn closure_cannot_assign_to_borrowed(&self, - span: Span, - descr: &str, - o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, span, E0595, "closure cannot assign to {}{OGN}", - descr, OGN=o); + fn closure_cannot_assign_to_borrowed( + self, + span: Span, + descr: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0595, + "closure cannot assign to {}{OGN}", + descr, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_borrow_path_as_mutable(&self, - span: Span, - path: &str, - o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, span, E0596, "cannot borrow {} as mutable{OGN}", - path, OGN=o); + fn cannot_borrow_path_as_mutable_because( + self, + span: Span, + path: &str, + reason: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0596, + "cannot borrow {} as mutable{}{OGN}", + path, + reason, + OGN = o, + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_borrow_across_generator_yield(&self, - span: Span, - yield_span: Span, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, - span, - E0626, - "borrow may still be in use when generator yields{OGN}", - OGN=o); + fn cannot_borrow_path_as_mutable( + self, + span: Span, + path: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + self.cannot_borrow_path_as_mutable_because(span, path, "", o) + } + + fn cannot_borrow_across_generator_yield( + self, + span: Span, + yield_span: Span, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + span, + E0626, + "borrow may still be in use when generator yields{OGN}", + OGN = o + ); err.span_label(yield_span, "possible yield occurs here"); self.cancel_if_wrong_origin(err, o) } - fn path_does_not_live_long_enough(&self, - span: Span, - path: &str, - o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, span, E0597, "{} does not live long enough{OGN}", - path, OGN=o); + fn path_does_not_live_long_enough( + self, + span: Span, + path: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0597, + "{} does not live long enough{OGN}", + path, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn lifetime_too_short_for_reborrow(&self, - span: Span, - path: &str, - o: Origin) - -> DiagnosticBuilder - { - let err = struct_span_err!(self, span, E0598, - "lifetime of {} is too short to guarantee \ - its contents can be safely reborrowed{OGN}", - path, OGN=o); + fn lifetime_too_short_for_reborrow( + self, + span: Span, + path: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0598, + "lifetime of {} is too short to guarantee \ + its contents can be safely reborrowed{OGN}", + path, + OGN = o + ); self.cancel_if_wrong_origin(err, o) } - fn cannot_act_on_capture_in_sharable_fn(&self, - span: Span, - bad_thing: &str, - help: (Span, &str), - o: Origin) - -> DiagnosticBuilder - { + fn cannot_act_on_capture_in_sharable_fn( + self, + span: Span, + bad_thing: &str, + help: (Span, &str), + o: Origin, + ) -> DiagnosticBuilder<'cx> { let (help_span, help_msg) = help; - let mut err = struct_span_err!(self, span, E0387, - "{} in a captured outer variable in an `Fn` closure{OGN}", - bad_thing, OGN=o); + let mut err = struct_span_err!( + self, + span, + E0387, + "{} in a captured outer variable in an `Fn` closure{OGN}", + bad_thing, + OGN = o + ); err.span_help(help_span, help_msg); self.cancel_if_wrong_origin(err, o) } - fn cannot_assign_into_immutable_reference(&self, - span: Span, - bad_thing: &str, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, span, E0389, "{} in a `&` reference{OGN}", - bad_thing, OGN=o); + fn cannot_assign_into_immutable_reference( + self, + span: Span, + bad_thing: &str, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + span, + E0389, + "{} in a `&` reference{OGN}", + bad_thing, + OGN = o + ); err.span_label(span, "assignment into an immutable reference"); self.cancel_if_wrong_origin(err, o) } - fn cannot_capture_in_long_lived_closure(&self, - closure_span: Span, - borrowed_path: &str, - capture_span: Span, - o: Origin) - -> DiagnosticBuilder - { - let mut err = struct_span_err!(self, closure_span, E0373, - "closure may outlive the current function, \ - but it borrows {}, \ - which is owned by the current function{OGN}", - borrowed_path, OGN=o); + fn cannot_capture_in_long_lived_closure( + self, + closure_span: Span, + borrowed_path: &str, + capture_span: Span, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let mut err = struct_span_err!( + self, + closure_span, + E0373, + "closure may outlive the current function, \ + but it borrows {}, \ + which is owned by the current function{OGN}", + borrowed_path, + OGN = o + ); err.span_label(capture_span, format!("{} is borrowed here", borrowed_path)) - .span_label(closure_span, format!("may outlive borrowed value {}", borrowed_path)); + .span_label( + closure_span, + format!("may outlive borrowed value {}", borrowed_path), + ); + + self.cancel_if_wrong_origin(err, o) + } + + fn thread_local_value_does_not_live_long_enough( + self, + span: Span, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + let err = struct_span_err!( + self, + span, + E0712, + "thread-local variable borrowed past end of function{OGN}", + OGN = o + ); self.cancel_if_wrong_origin(err, o) } } -impl<'b, 'gcx, 'tcx> BorrowckErrors for TyCtxt<'b, 'gcx, 'tcx> { - fn struct_span_err_with_code<'a, S: Into<MultiSpan>>(&'a self, - sp: S, - msg: &str, - code: DiagnosticId) - -> DiagnosticBuilder<'a> - { +impl<'cx, 'gcx, 'tcx> BorrowckErrors<'cx> for TyCtxt<'cx, 'gcx, 'tcx> { + fn struct_span_err_with_code<S: Into<MultiSpan>>( + self, + sp: S, + msg: &str, + code: DiagnosticId, + ) -> DiagnosticBuilder<'cx> { self.sess.struct_span_err_with_code(sp, msg, code) } - fn struct_span_err<'a, S: Into<MultiSpan>>(&'a self, - sp: S, - msg: &str) - -> DiagnosticBuilder<'a> - { + fn struct_span_err<S: Into<MultiSpan>>(self, sp: S, msg: &str) -> DiagnosticBuilder<'cx> { self.sess.struct_span_err(sp, msg) } - fn cancel_if_wrong_origin<'a>(&'a self, - mut diag: DiagnosticBuilder<'a>, - o: Origin) - -> DiagnosticBuilder<'a> - { - if !o.should_emit_errors(self.sess.borrowck_mode()) { + fn cancel_if_wrong_origin( + self, + mut diag: DiagnosticBuilder<'cx>, + o: Origin, + ) -> DiagnosticBuilder<'cx> { + if !o.should_emit_errors(self.borrowck_mode()) { self.sess.diagnostic().cancel(&mut diag); } diag |