[rustc.git] / src / librustc / infer / error_reporting / note.rs

// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use infer::{self, InferCtxt, SubregionOrigin};
use middle::region;
use ty::{self, Region};
use ty::error::TypeError;
use errors::DiagnosticBuilder;

impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
    pub(super) fn note_region_origin(&self,
                                     err: &mut DiagnosticBuilder,
                                     origin: &SubregionOrigin<'tcx>) {
        match *origin {
            infer::Subtype(ref trace) => {
                if let Some((expected, found)) = self.values_str(&trace.values) {
                    let expected = expected.content();
                    let found = found.content();
                    // FIXME: do we want a "the" here?
                    err.span_note(trace.cause.span,
                                  &format!("...so that {} (expected {}, found {})",
                                           trace.cause.as_requirement_str(),
                                           expected,
                                           found));
                } else {
                    // FIXME: this really should be handled at some earlier stage. Our
                    // handling of region checking when type errors are present is
                    // *terrible*.

                    err.span_note(trace.cause.span,
                                  &format!("...so that {}", trace.cause.as_requirement_str()));
                }
            }
            infer::Reborrow(span) => {
                err.span_note(span,
                              "...so that reference does not outlive borrowed content");
            }
            infer::ReborrowUpvar(span, ref upvar_id) => {
                let var_node_id = self.tcx.hir.hir_to_node_id(upvar_id.var_id);
                let var_name = self.tcx.hir.name(var_node_id);
                err.span_note(span,
                              &format!("...so that closure can access `{}`", var_name));
            }
            infer::InfStackClosure(span) => {
                err.span_note(span, "...so that closure does not outlive its stack frame");
            }
            infer::InvokeClosure(span) => {
                err.span_note(span,
                              "...so that closure is not invoked outside its lifetime");
            }
            infer::DerefPointer(span) => {
                err.span_note(span,
                              "...so that pointer is not dereferenced outside its lifetime");
            }
            infer::FreeVariable(span, id) => {
                err.span_note(span,
                              &format!("...so that captured variable `{}` does not outlive the \
                                        enclosing closure",
                                       self.tcx.hir.name(id)));
            }
            infer::IndexSlice(span) => {
                err.span_note(span, "...so that slice is not indexed outside the lifetime");
            }
            infer::RelateObjectBound(span) => {
                err.span_note(span, "...so that it can be closed over into an object");
            }
            infer::CallRcvr(span) => {
                err.span_note(span,
                              "...so that method receiver is valid for the method call");
            }
            infer::CallArg(span) => {
                err.span_note(span, "...so that argument is valid for the call");
            }
            infer::CallReturn(span) => {
                err.span_note(span, "...so that return value is valid for the call");
            }
            infer::Operand(span) => {
                err.span_note(span, "...so that operand is valid for operation");
            }
            infer::AddrOf(span) => {
                err.span_note(span, "...so that reference is valid at the time of borrow");
            }
            infer::AutoBorrow(span) => {
                err.span_note(span,
                              "...so that auto-reference is valid at the time of borrow");
            }
            infer::ExprTypeIsNotInScope(t, span) => {
                err.span_note(span,
                              &format!("...so type `{}` of expression is valid during the \
                                        expression",
                                       self.ty_to_string(t)));
            }
            infer::BindingTypeIsNotValidAtDecl(span) => {
                err.span_note(span,
                              "...so that variable is valid at time of its declaration");
            }
            infer::ParameterInScope(_, span) => {
                err.span_note(span,
                              "...so that a type/lifetime parameter is in scope here");
            }
            infer::DataBorrowed(ty, span) => {
                err.span_note(span,
                              &format!("...so that the type `{}` is not borrowed for too long",
                                       self.ty_to_string(ty)));
            }
            infer::ReferenceOutlivesReferent(ty, span) => {
                err.span_note(span,
                              &format!("...so that the reference type `{}` does not outlive the \
                                        data it points at",
                                       self.ty_to_string(ty)));
            }
            infer::RelateParamBound(span, t) => {
                err.span_note(span,
                              &format!("...so that the type `{}` will meet its required \
                                        lifetime bounds",
                                       self.ty_to_string(t)));
            }
            infer::RelateDefaultParamBound(span, t) => {
                err.span_note(span,
                              &format!("...so that type parameter instantiated with `{}`, will \
                                        meet its declared lifetime bounds",
                                       self.ty_to_string(t)));
            }
            infer::RelateRegionParamBound(span) => {
                err.span_note(span,
                              "...so that the declared lifetime parameter bounds are satisfied");
            }
            infer::SafeDestructor(span) => {
                err.span_note(span,
                              "...so that references are valid when the destructor runs");
            }
            infer::CompareImplMethodObligation { span, .. } => {
                err.span_note(span,
                              "...so that the definition in impl matches the definition from the \
                               trait");
            }
        }
    }

    pub(super) fn report_concrete_failure(&self,
                                          region_scope_tree: &region::ScopeTree,
                                          origin: SubregionOrigin<'tcx>,
                                          sub: Region<'tcx>,
                                          sup: Region<'tcx>)
                                          -> DiagnosticBuilder<'tcx> {
        match origin {
            infer::Subtype(trace) => {
                let terr = TypeError::RegionsDoesNotOutlive(sup, sub);
                let mut err = self.report_and_explain_type_error(trace, &terr);
                self.tcx.note_and_explain_region(region_scope_tree, &mut err, "", sup, "...");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "...does not necessarily outlive ", sub, "");
                err
            }
            infer::Reborrow(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0312,
                                               "lifetime of reference outlives lifetime of \
                                                borrowed content...");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "...the reference is valid for ",
                                                 sub,
                                                 "...");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "...but the borrowed content is only valid for ",
                                                 sup,
                                                 "");
                err
            }
            infer::ReborrowUpvar(span, ref upvar_id) => {
                let var_node_id = self.tcx.hir.hir_to_node_id(upvar_id.var_id);
                let var_name = self.tcx.hir.name(var_node_id);
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0313,
                                               "lifetime of borrowed pointer outlives lifetime \
                                                of captured variable `{}`...",
                                               var_name);
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "...the borrowed pointer is valid for ",
                                                 sub,
                                                 "...");
                self.tcx.note_and_explain_region(
                    region_scope_tree,
                    &mut err,
                    &format!("...but `{}` is only valid for ", var_name),
                    sup,
                    "");
                err
            }
            infer::InfStackClosure(span) => {
                let mut err =
                    struct_span_err!(self.tcx.sess, span, E0314, "closure outlives stack frame");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "...the closure must be valid for ",
                                                 sub,
                                                 "...");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "...but the closure's stack frame is only valid \
                                                  for ",
                                                 sup,
                                                 "");
                err
            }
            infer::InvokeClosure(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0315,
                                               "cannot invoke closure outside of its lifetime");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the closure is only valid for ", sup, "");
                err
            }
            infer::DerefPointer(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0473,
                                               "dereference of reference outside its lifetime");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the reference is only valid for ", sup, "");
                err
            }
            infer::FreeVariable(span, id) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0474,
                                               "captured variable `{}` does not outlive the \
                                                enclosing closure",
                                               self.tcx.hir.name(id));
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "captured variable is valid for ", sup, "");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "closure is valid for ", sub, "");
                err
            }
            infer::IndexSlice(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0475,
                                               "index of slice outside its lifetime");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the slice is only valid for ", sup, "");
                err
            }
            infer::RelateObjectBound(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0476,
                                               "lifetime of the source pointer does not outlive \
                                                lifetime bound of the object type");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "object type is valid for ", sub, "");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "source pointer is only valid for ",
                                                 sup,
                                                 "");
                err
            }
            infer::RelateParamBound(span, ty) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0477,
                                               "the type `{}` does not fulfill the required \
                                                lifetime",
                                               self.ty_to_string(ty));
                match *sub {
                    ty::ReStatic => {
                        self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                            "type must satisfy ", sub, "")
                    }
                    _ => {
                        self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                            "type must outlive ", sub, "")
                    }
                }
                err
            }
            infer::RelateRegionParamBound(span) => {
                let mut err =
                    struct_span_err!(self.tcx.sess, span, E0478, "lifetime bound not satisfied");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "lifetime parameter instantiated with ",
                                                 sup,
                                                 "");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "but lifetime parameter must outlive ",
                                                 sub,
                                                 "");
                err
            }
            infer::RelateDefaultParamBound(span, ty) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0479,
                                               "the type `{}` (provided as the value of a type \
                                                parameter) is not valid at this point",
                                               self.ty_to_string(ty));
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "type must outlive ", sub, "");
                err
            }
            infer::CallRcvr(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0480,
                                               "lifetime of method receiver does not outlive the \
                                                method call");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                "the receiver is only valid for ", sup, "");
                err
            }
            infer::CallArg(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0481,
                                               "lifetime of function argument does not outlive \
                                                the function call");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "the function argument is only valid for ",
                                                 sup,
                                                 "");
                err
            }
            infer::CallReturn(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0482,
                                               "lifetime of return value does not outlive the \
                                                function call");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "the return value is only valid for ",
                                                 sup,
                                                 "");
                err
            }
            infer::Operand(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0483,
                                               "lifetime of operand does not outlive the \
                                                operation");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the operand is only valid for ", sup, "");
                err
            }
            infer::AddrOf(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0484,
                                               "reference is not valid at the time of borrow");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the borrow is only valid for ", sup, "");
                err
            }
            infer::AutoBorrow(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0485,
                                               "automatically reference is not valid at the time \
                                                of borrow");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "the automatic borrow is only valid for ",
                                                 sup,
                                                 "");
                err
            }
            infer::ExprTypeIsNotInScope(t, span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0486,
                                               "type of expression contains references that are \
                                                not valid during the expression: `{}`",
                                               self.ty_to_string(t));
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "type is only valid for ", sup, "");
                err
            }
            infer::SafeDestructor(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0487,
                                               "unsafe use of destructor: destructor might be \
                                                called while references are dead");
                // FIXME (22171): terms "super/subregion" are suboptimal
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "superregion: ", sup, "");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "subregion: ", sub, "");
                err
            }
            infer::BindingTypeIsNotValidAtDecl(span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0488,
                                               "lifetime of variable does not enclose its \
                                                declaration");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the variable is only valid for ", sup, "");
                err
            }
            infer::ParameterInScope(_, span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0489,
                                               "type/lifetime parameter not in scope here");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the parameter is only valid for ", sub, "");
                err
            }
            infer::DataBorrowed(ty, span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0490,
                                               "a value of type `{}` is borrowed for too long",
                                               self.ty_to_string(ty));
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the type is valid for ", sub, "");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "but the borrow lasts for ", sup, "");
                err
            }
            infer::ReferenceOutlivesReferent(ty, span) => {
                let mut err = struct_span_err!(self.tcx.sess,
                                               span,
                                               E0491,
                                               "in type `{}`, reference has a longer lifetime \
                                                than the data it references",
                                               self.ty_to_string(ty));
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                    "the pointer is valid for ", sub, "");
                self.tcx.note_and_explain_region(region_scope_tree, &mut err,
                                                 "but the referenced data is only valid for ",
                                                 sup,
                                                 "");
                err
            }
            infer::CompareImplMethodObligation { span,
                                                 item_name,
                                                 impl_item_def_id,
                                                 trait_item_def_id,
                                                 lint_id } => {
                self.report_extra_impl_obligation(span,
                                                  item_name,
                                                  impl_item_def_id,
                                                  trait_item_def_id,
                                                  &format!("`{}: {}`", sup, sub),
                                                  lint_id)
            }
        }
    }
}
Commit	Line	Data
8bb4bdeb XL	1	// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
	2	// file at the top-level directory of this distribution and at
	3	// http://rust-lang.org/COPYRIGHT.
	4	//
	5	// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
	6	// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
	7	// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
	8	// option. This file may not be copied, modified, or distributed
	9	// except according to those terms.
	10
	11	use infer::{self, InferCtxt, SubregionOrigin};
ea8adc8c	12	use middle::region;
7cac9316	13	use ty::{self, Region};
8bb4bdeb XL	14	use ty::error::TypeError;
	15	use errors::DiagnosticBuilder;
	16
	17	impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
	18	pub(super) fn note_region_origin(&self,
	19	err: &mut DiagnosticBuilder,
	20	origin: &SubregionOrigin<'tcx>) {
	21	match *origin {
	22	infer::Subtype(ref trace) => {
	23	if let Some((expected, found)) = self.values_str(&trace.values) {
cc61c64b XL	24	let expected = expected.content();
cc61c64b XL	25	let found = found.content();
8bb4bdeb XL	26	// FIXME: do we want a "the" here?
	27	err.span_note(trace.cause.span,
	28	&format!("...so that {} (expected {}, found {})",
	29	trace.cause.as_requirement_str(),
	30	expected,
	31	found));
	32	} else {
	33	// FIXME: this really should be handled at some earlier stage. Our
	34	// handling of region checking when type errors are present is
	35	// terrible.
	36
	37	err.span_note(trace.cause.span,
	38	&format!("...so that {}", trace.cause.as_requirement_str()));
	39	}
	40	}
	41	infer::Reborrow(span) => {
	42	err.span_note(span,
	43	"...so that reference does not outlive borrowed content");
	44	}
	45	infer::ReborrowUpvar(span, ref upvar_id) => {
ea8adc8c XL	46	let var_node_id = self.tcx.hir.hir_to_node_id(upvar_id.var_id);
ea8adc8c XL	47	let var_name = self.tcx.hir.name(var_node_id);
8bb4bdeb	48	err.span_note(span,
ea8adc8c	49	&format!("...so that closure can access `{}`", var_name));
8bb4bdeb XL	50	}
	51	infer::InfStackClosure(span) => {
	52	err.span_note(span, "...so that closure does not outlive its stack frame");
	53	}
	54	infer::InvokeClosure(span) => {
	55	err.span_note(span,
	56	"...so that closure is not invoked outside its lifetime");
	57	}
	58	infer::DerefPointer(span) => {
	59	err.span_note(span,
	60	"...so that pointer is not dereferenced outside its lifetime");
	61	}
	62	infer::FreeVariable(span, id) => {
	63	err.span_note(span,
	64	&format!("...so that captured variable `{}` does not outlive the \
	65	enclosing closure",
ea8adc8c	66	self.tcx.hir.name(id)));
8bb4bdeb XL	67	}
	68	infer::IndexSlice(span) => {
	69	err.span_note(span, "...so that slice is not indexed outside the lifetime");
	70	}
	71	infer::RelateObjectBound(span) => {
	72	err.span_note(span, "...so that it can be closed over into an object");
	73	}
	74	infer::CallRcvr(span) => {
	75	err.span_note(span,
	76	"...so that method receiver is valid for the method call");
	77	}
	78	infer::CallArg(span) => {
	79	err.span_note(span, "...so that argument is valid for the call");
	80	}
	81	infer::CallReturn(span) => {
	82	err.span_note(span, "...so that return value is valid for the call");
	83	}
	84	infer::Operand(span) => {
	85	err.span_note(span, "...so that operand is valid for operation");
	86	}
	87	infer::AddrOf(span) => {
	88	err.span_note(span, "...so that reference is valid at the time of borrow");
	89	}
	90	infer::AutoBorrow(span) => {
	91	err.span_note(span,
	92	"...so that auto-reference is valid at the time of borrow");
	93	}
	94	infer::ExprTypeIsNotInScope(t, span) => {
	95	err.span_note(span,
	96	&format!("...so type `{}` of expression is valid during the \
	97	expression",
	98	self.ty_to_string(t)));
	99	}
	100	infer::BindingTypeIsNotValidAtDecl(span) => {
	101	err.span_note(span,
	102	"...so that variable is valid at time of its declaration");
	103	}
	104	infer::ParameterInScope(_, span) => {
	105	err.span_note(span,
	106	"...so that a type/lifetime parameter is in scope here");
	107	}
	108	infer::DataBorrowed(ty, span) => {
	109	err.span_note(span,
	110	&format!("...so that the type `{}` is not borrowed for too long",
	111	self.ty_to_string(ty)));
	112	}
	113	infer::ReferenceOutlivesReferent(ty, span) => {
	114	err.span_note(span,
	115	&format!("...so that the reference type `{}` does not outlive the \
	116	data it points at",
	117	self.ty_to_string(ty)));
	118	}
	119	infer::RelateParamBound(span, t) => {
	120	err.span_note(span,
	121	&format!("...so that the type `{}` will meet its required \
	122	lifetime bounds",
	123	self.ty_to_string(t)));
	124	}
	125	infer::RelateDefaultParamBound(span, t) => {
	126	err.span_note(span,
	127	&format!("...so that type parameter instantiated with `{}`, will \
	128	meet its declared lifetime bounds",
	129	self.ty_to_string(t)));
	130	}
131	infer::RelateRegionParamBound(span) => {
132	err.span_note(span,
133	"...so that the declared lifetime parameter bounds are satisfied");
134	}
135	infer::SafeDestructor(span) => {
136	err.span_note(span,
137	"...so that references are valid when the destructor runs");
138	}
139	infer::CompareImplMethodObligation { span, .. } => {
140	err.span_note(span,
141	"...so that the definition in impl matches the definition from the \
142	trait");
143	}
144	}
145	}
146
147	pub(super) fn report_concrete_failure(&self,
ea8adc8c	148	region_scope_tree: &region::ScopeTree,
8bb4bdeb	149	origin: SubregionOrigin<'tcx>,
7cac9316 XL	150	sub: Region<'tcx>,
7cac9316 XL	151	sup: Region<'tcx>)
8bb4bdeb XL	152	-> DiagnosticBuilder<'tcx> {
	153	match origin {
	154	infer::Subtype(trace) => {
	155	let terr = TypeError::RegionsDoesNotOutlive(sup, sub);
ea8adc8c XL	156	let mut err = self.report_and_explain_type_error(trace, &terr);
	157	self.tcx.note_and_explain_region(region_scope_tree, &mut err, "", sup, "...");
	158	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	159	"...does not necessarily outlive ", sub, "");
	160	err
8bb4bdeb XL	161	}
	162	infer::Reborrow(span) => {
	163	let mut err = struct_span_err!(self.tcx.sess,
	164	span,
	165	E0312,
	166	"lifetime of reference outlives lifetime of \
	167	borrowed content...");
ea8adc8c	168	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	169	"...the reference is valid for ",
	170	sub,
	171	"...");
ea8adc8c	172	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	173	"...but the borrowed content is only valid for ",
	174	sup,
	175	"");
	176	err
	177	}
	178	infer::ReborrowUpvar(span, ref upvar_id) => {
ea8adc8c XL	179	let var_node_id = self.tcx.hir.hir_to_node_id(upvar_id.var_id);
ea8adc8c XL	180	let var_name = self.tcx.hir.name(var_node_id);
8bb4bdeb XL	181	let mut err = struct_span_err!(self.tcx.sess,
	182	span,
	183	E0313,
	184	"lifetime of borrowed pointer outlives lifetime \
	185	of captured variable `{}`...",
ea8adc8c XL	186	var_name);
ea8adc8c XL	187	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	188	"...the borrowed pointer is valid for ",
	189	sub,
	190	"...");
ea8adc8c XL	191	self.tcx.note_and_explain_region(
	192	region_scope_tree,
	193	&mut err,
	194	&format!("...but `{}` is only valid for ", var_name),
	195	sup,
	196	"");
8bb4bdeb XL	197	err
	198	}
	199	infer::InfStackClosure(span) => {
	200	let mut err =
	201	struct_span_err!(self.tcx.sess, span, E0314, "closure outlives stack frame");
ea8adc8c	202	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	203	"...the closure must be valid for ",
	204	sub,
	205	"...");
ea8adc8c	206	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	207	"...but the closure's stack frame is only valid \
	208	for ",
	209	sup,
	210	"");
	211	err
	212	}
	213	infer::InvokeClosure(span) => {
	214	let mut err = struct_span_err!(self.tcx.sess,
	215	span,
	216	E0315,
	217	"cannot invoke closure outside of its lifetime");
ea8adc8c XL	218	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	219	"the closure is only valid for ", sup, "");
8bb4bdeb XL	220	err
	221	}
	222	infer::DerefPointer(span) => {
	223	let mut err = struct_span_err!(self.tcx.sess,
	224	span,
	225	E0473,
	226	"dereference of reference outside its lifetime");
ea8adc8c XL	227	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	228	"the reference is only valid for ", sup, "");
8bb4bdeb XL	229	err
	230	}
	231	infer::FreeVariable(span, id) => {
	232	let mut err = struct_span_err!(self.tcx.sess,
	233	span,
	234	E0474,
	235	"captured variable `{}` does not outlive the \
	236	enclosing closure",
ea8adc8c XL	237	self.tcx.hir.name(id));
	238	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	239	"captured variable is valid for ", sup, "");
	240	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	241	"closure is valid for ", sub, "");
8bb4bdeb XL	242	err
	243	}
	244	infer::IndexSlice(span) => {
	245	let mut err = struct_span_err!(self.tcx.sess,
	246	span,
	247	E0475,
	248	"index of slice outside its lifetime");
ea8adc8c XL	249	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	250	"the slice is only valid for ", sup, "");
8bb4bdeb XL	251	err
	252	}
	253	infer::RelateObjectBound(span) => {
	254	let mut err = struct_span_err!(self.tcx.sess,
	255	span,
	256	E0476,
	257	"lifetime of the source pointer does not outlive \
	258	lifetime bound of the object type");
ea8adc8c XL	259	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	260	"object type is valid for ", sub, "");
	261	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	262	"source pointer is only valid for ",
	263	sup,
	264	"");
	265	err
	266	}
	267	infer::RelateParamBound(span, ty) => {
	268	let mut err = struct_span_err!(self.tcx.sess,
	269	span,
	270	E0477,
	271	"the type `{}` does not fulfill the required \
	272	lifetime",
	273	self.ty_to_string(ty));
7cac9316 XL	274	match *sub {
7cac9316 XL	275	ty::ReStatic => {
ea8adc8c XL	276	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	277	"type must satisfy ", sub, "")
7cac9316 XL	278	}
7cac9316 XL	279	_ => {
ea8adc8c XL	280	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	281	"type must outlive ", sub, "")
7cac9316 XL	282	}
7cac9316 XL	283	}
8bb4bdeb XL	284	err
	285	}
	286	infer::RelateRegionParamBound(span) => {
	287	let mut err =
	288	struct_span_err!(self.tcx.sess, span, E0478, "lifetime bound not satisfied");
ea8adc8c	289	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	290	"lifetime parameter instantiated with ",
	291	sup,
	292	"");
ea8adc8c	293	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	294	"but lifetime parameter must outlive ",
	295	sub,
	296	"");
	297	err
	298	}
	299	infer::RelateDefaultParamBound(span, ty) => {
	300	let mut err = struct_span_err!(self.tcx.sess,
	301	span,
	302	E0479,
	303	"the type `{}` (provided as the value of a type \
	304	parameter) is not valid at this point",
	305	self.ty_to_string(ty));
ea8adc8c XL	306	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	307	"type must outlive ", sub, "");
8bb4bdeb XL	308	err
	309	}
	310	infer::CallRcvr(span) => {
	311	let mut err = struct_span_err!(self.tcx.sess,
	312	span,
	313	E0480,
	314	"lifetime of method receiver does not outlive the \
	315	method call");
ea8adc8c XL	316	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	317	"the receiver is only valid for ", sup, "");
8bb4bdeb XL	318	err
	319	}
	320	infer::CallArg(span) => {
	321	let mut err = struct_span_err!(self.tcx.sess,
	322	span,
	323	E0481,
	324	"lifetime of function argument does not outlive \
	325	the function call");
ea8adc8c	326	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	327	"the function argument is only valid for ",
	328	sup,
	329	"");
	330	err
	331	}
	332	infer::CallReturn(span) => {
	333	let mut err = struct_span_err!(self.tcx.sess,
	334	span,
	335	E0482,
	336	"lifetime of return value does not outlive the \
	337	function call");
ea8adc8c	338	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	339	"the return value is only valid for ",
	340	sup,
	341	"");
	342	err
	343	}
	344	infer::Operand(span) => {
	345	let mut err = struct_span_err!(self.tcx.sess,
	346	span,
	347	E0483,
	348	"lifetime of operand does not outlive the \
	349	operation");
ea8adc8c XL	350	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	351	"the operand is only valid for ", sup, "");
8bb4bdeb XL	352	err
	353	}
	354	infer::AddrOf(span) => {
	355	let mut err = struct_span_err!(self.tcx.sess,
	356	span,
	357	E0484,
	358	"reference is not valid at the time of borrow");
ea8adc8c XL	359	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	360	"the borrow is only valid for ", sup, "");
8bb4bdeb XL	361	err
	362	}
	363	infer::AutoBorrow(span) => {
	364	let mut err = struct_span_err!(self.tcx.sess,
	365	span,
	366	E0485,
	367	"automatically reference is not valid at the time \
	368	of borrow");
ea8adc8c	369	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	370	"the automatic borrow is only valid for ",
	371	sup,
	372	"");
	373	err
	374	}
	375	infer::ExprTypeIsNotInScope(t, span) => {
	376	let mut err = struct_span_err!(self.tcx.sess,
	377	span,
	378	E0486,
	379	"type of expression contains references that are \
	380	not valid during the expression: `{}`",
	381	self.ty_to_string(t));
ea8adc8c XL	382	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	383	"type is only valid for ", sup, "");
8bb4bdeb XL	384	err
	385	}
	386	infer::SafeDestructor(span) => {
	387	let mut err = struct_span_err!(self.tcx.sess,
	388	span,
	389	E0487,
	390	"unsafe use of destructor: destructor might be \
	391	called while references are dead");
	392	// FIXME (22171): terms "super/subregion" are suboptimal
ea8adc8c XL	393	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	394	"superregion: ", sup, "");
	395	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	396	"subregion: ", sub, "");
8bb4bdeb XL	397	err
	398	}
	399	infer::BindingTypeIsNotValidAtDecl(span) => {
	400	let mut err = struct_span_err!(self.tcx.sess,
	401	span,
	402	E0488,
	403	"lifetime of variable does not enclose its \
	404	declaration");
ea8adc8c XL	405	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	406	"the variable is only valid for ", sup, "");
8bb4bdeb XL	407	err
	408	}
	409	infer::ParameterInScope(_, span) => {
	410	let mut err = struct_span_err!(self.tcx.sess,
	411	span,
	412	E0489,
	413	"type/lifetime parameter not in scope here");
ea8adc8c XL	414	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
ea8adc8c XL	415	"the parameter is only valid for ", sub, "");
8bb4bdeb XL	416	err
	417	}
	418	infer::DataBorrowed(ty, span) => {
	419	let mut err = struct_span_err!(self.tcx.sess,
	420	span,
	421	E0490,
	422	"a value of type `{}` is borrowed for too long",
	423	self.ty_to_string(ty));
ea8adc8c XL	424	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	425	"the type is valid for ", sub, "");
	426	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	427	"but the borrow lasts for ", sup, "");
8bb4bdeb XL	428	err
	429	}
	430	infer::ReferenceOutlivesReferent(ty, span) => {
	431	let mut err = struct_span_err!(self.tcx.sess,
	432	span,
	433	E0491,
	434	"in type `{}`, reference has a longer lifetime \
	435	than the data it references",
	436	self.ty_to_string(ty));
ea8adc8c XL	437	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
	438	"the pointer is valid for ", sub, "");
	439	self.tcx.note_and_explain_region(region_scope_tree, &mut err,
8bb4bdeb XL	440	"but the referenced data is only valid for ",
	441	sup,
	442	"");
	443	err
	444	}
	445	infer::CompareImplMethodObligation { span,
	446	item_name,
	447	impl_item_def_id,
	448	trait_item_def_id,
	449	lint_id } => {
	450	self.report_extra_impl_obligation(span,
	451	item_name,
	452	impl_item_def_id,
	453	trait_item_def_id,
	454	&format!("`{}: {}`", sup, sub),
	455	lint_id)
	456	}
	457	}
	458	}
	459	}