Format note.rs with rustfmt
This commit is contained in:
Cengiz Can
parent
2f8ef50f7d
commit
e136bf6a4c
@ -14,184 +14,150 @@ 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>) {
|
||||
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) {
|
||||
// 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));
|
||||
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()));
|
||||
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");
|
||||
err.span_note(span,
|
||||
"...so that reference does not outlive borrowed content");
|
||||
}
|
||||
infer::ReborrowUpvar(span, ref upvar_id) => {
|
||||
err.span_note(
|
||||
span,
|
||||
&format!(
|
||||
"...so that closure can access `{}`",
|
||||
self.tcx.local_var_name_str(upvar_id.var_id)
|
||||
.to_string()));
|
||||
err.span_note(span,
|
||||
&format!("...so that closure can access `{}`",
|
||||
self.tcx
|
||||
.local_var_name_str(upvar_id.var_id)
|
||||
.to_string()));
|
||||
}
|
||||
infer::InfStackClosure(span) => {
|
||||
err.span_note(
|
||||
span,
|
||||
"...so that closure does not outlive its stack frame");
|
||||
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");
|
||||
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");
|
||||
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.local_var_name_str(id)));
|
||||
err.span_note(span,
|
||||
&format!("...so that captured variable `{}` does not outlive the \
|
||||
enclosing closure",
|
||||
self.tcx.local_var_name_str(id)));
|
||||
}
|
||||
infer::IndexSlice(span) => {
|
||||
err.span_note(
|
||||
span,
|
||||
"...so that slice is not indexed outside the lifetime");
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
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)));
|
||||
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");
|
||||
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");
|
||||
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)));
|
||||
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)));
|
||||
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)));
|
||||
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)));
|
||||
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");
|
||||
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");
|
||||
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");
|
||||
err.span_note(span,
|
||||
"...so that the definition in impl matches the definition from the \
|
||||
trait");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn report_concrete_failure(&self,
|
||||
origin: SubregionOrigin<'tcx>,
|
||||
sub: &'tcx Region,
|
||||
sup: &'tcx Region)
|
||||
-> DiagnosticBuilder<'tcx> {
|
||||
origin: SubregionOrigin<'tcx>,
|
||||
sub: &'tcx Region,
|
||||
sup: &'tcx Region)
|
||||
-> DiagnosticBuilder<'tcx> {
|
||||
match origin {
|
||||
infer::Subtype(trace) => {
|
||||
let terr = TypeError::RegionsDoesNotOutlive(sup, sub);
|
||||
self.report_and_explain_type_error(trace, &terr)
|
||||
}
|
||||
infer::Reborrow(span) => {
|
||||
let mut err = struct_span_err!(self.tcx.sess, span, E0312,
|
||||
"lifetime of reference outlives \
|
||||
lifetime of borrowed content...");
|
||||
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(&mut err,
|
||||
"...the reference is valid for ",
|
||||
sub,
|
||||
@ -203,83 +169,84 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
||||
err
|
||||
}
|
||||
infer::ReborrowUpvar(span, ref upvar_id) => {
|
||||
let mut err = struct_span_err!(self.tcx.sess, span, E0313,
|
||||
"lifetime of borrowed pointer outlives \
|
||||
lifetime of captured variable `{}`...",
|
||||
self.tcx.local_var_name_str(upvar_id.var_id));
|
||||
let mut err = struct_span_err!(self.tcx.sess,
|
||||
span,
|
||||
E0313,
|
||||
"lifetime of borrowed pointer outlives lifetime \
|
||||
of captured variable `{}`...",
|
||||
self.tcx.local_var_name_str(upvar_id.var_id));
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"...the borrowed pointer is valid for ",
|
||||
sub,
|
||||
"...");
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
&format!("...but `{}` is only valid for ",
|
||||
self.tcx.local_var_name_str(upvar_id.var_id)),
|
||||
sup,
|
||||
"");
|
||||
self.tcx
|
||||
.note_and_explain_region(&mut err,
|
||||
&format!("...but `{}` is only valid for ",
|
||||
self.tcx
|
||||
.local_var_name_str(upvar_id.var_id)),
|
||||
sup,
|
||||
"");
|
||||
err
|
||||
}
|
||||
infer::InfStackClosure(span) => {
|
||||
let mut err = struct_span_err!(self.tcx.sess, span, E0314,
|
||||
"closure outlives stack frame");
|
||||
let mut err =
|
||||
struct_span_err!(self.tcx.sess, span, E0314, "closure outlives stack frame");
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"...the closure must be valid for ",
|
||||
sub,
|
||||
"...");
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"...but the closure's stack frame is only valid for ",
|
||||
"...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(&mut err,
|
||||
"the closure is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
let mut err = struct_span_err!(self.tcx.sess,
|
||||
span,
|
||||
E0315,
|
||||
"cannot invoke closure outside of its lifetime");
|
||||
self.tcx
|
||||
.note_and_explain_region(&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(&mut err,
|
||||
"the reference is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
let mut err = struct_span_err!(self.tcx.sess,
|
||||
span,
|
||||
E0473,
|
||||
"dereference of reference outside its lifetime");
|
||||
self.tcx
|
||||
.note_and_explain_region(&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.local_var_name_str(id));
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"captured variable is valid for ",
|
||||
sup,
|
||||
"");
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"closure is valid for ",
|
||||
sub,
|
||||
"");
|
||||
let mut err = struct_span_err!(self.tcx.sess,
|
||||
span,
|
||||
E0474,
|
||||
"captured variable `{}` does not outlive the \
|
||||
enclosing closure",
|
||||
self.tcx.local_var_name_str(id));
|
||||
self.tcx
|
||||
.note_and_explain_region(&mut err, "captured variable is valid for ", sup, "");
|
||||
self.tcx.note_and_explain_region(&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(&mut err,
|
||||
"the slice is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
let mut err = struct_span_err!(self.tcx.sess,
|
||||
span,
|
||||
E0475,
|
||||
"index of slice outside its lifetime");
|
||||
self.tcx.note_and_explain_region(&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(&mut err,
|
||||
"object type is valid for ",
|
||||
sub,
|
||||
"");
|
||||
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(&mut err, "object type is valid for ", sub, "");
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"source pointer is only valid for ",
|
||||
sup,
|
||||
@ -287,18 +254,18 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
||||
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));
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"type must outlive ",
|
||||
sub,
|
||||
"");
|
||||
let mut err = struct_span_err!(self.tcx.sess,
|
||||
span,
|
||||
E0477,
|
||||
"the type `{}` does not fulfill the required \
|
||||
lifetime",
|
||||
self.ty_to_string(ty));
|
||||
self.tcx.note_and_explain_region(&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");
|
||||
let mut err =
|
||||
struct_span_err!(self.tcx.sess, span, E0478, "lifetime bound not satisfied");
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"lifetime parameter instantiated with ",
|
||||
sup,
|
||||
@ -310,30 +277,31 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
||||
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(&mut err,
|
||||
"type must outlive ",
|
||||
sub,
|
||||
"");
|
||||
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(&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(&mut err,
|
||||
"the receiver is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
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(&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");
|
||||
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(&mut err,
|
||||
"the function argument is only valid for ",
|
||||
sup,
|
||||
@ -341,9 +309,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
||||
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");
|
||||
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(&mut err,
|
||||
"the return value is only valid for ",
|
||||
sup,
|
||||
@ -351,28 +321,30 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
||||
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(&mut err,
|
||||
"the operand is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
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(&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(&mut err,
|
||||
"the borrow is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
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(&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");
|
||||
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(&mut err,
|
||||
"the automatic borrow is only valid for ",
|
||||
sup,
|
||||
@ -380,79 +352,74 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
||||
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(&mut err,
|
||||
"type is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
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(&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");
|
||||
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(&mut err,
|
||||
"superregion: ",
|
||||
sup,
|
||||
"");
|
||||
self.tcx.note_and_explain_region(&mut err,
|
||||
"subregion: ",
|
||||
sub,
|
||||
"");
|
||||
self.tcx.note_and_explain_region(&mut err, "superregion: ", sup, "");
|
||||
self.tcx.note_and_explain_region(&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(&mut err,
|
||||
"the variable is only valid for ",
|
||||
sup,
|
||||
"");
|
||||
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(&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(&mut err,
|
||||
"the parameter is only valid for ",
|
||||
sub,
|
||||
"");
|
||||
let mut err = struct_span_err!(self.tcx.sess,
|
||||
span,
|
||||
E0489,
|
||||
"type/lifetime parameter not in scope here");
|
||||
self.tcx
|
||||
.note_and_explain_region(&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));
|
||||
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(&mut err, "the type is valid for ", sub, "");
|
||||
self.tcx.note_and_explain_region(&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(&mut err,
|
||||
"the pointer is valid for ",
|
||||
sub,
|
||||
"");
|
||||
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(&mut err, "the pointer is valid for ", sub, "");
|
||||
self.tcx.note_and_explain_region(&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
|
||||
} => {
|
||||
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,
|
||||
@ -462,4 +429,4 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user