mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove unused error reporting code

Browse Source
This commit is contained in:
Matthew Jasper 2020-05-19 21:25:07 +01:00
parent 7d73e4cc47
commit 52d628f250
4 changed files with 0 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/librustc_infer/infer/error_reporting/nice_region_error/mod.rs
View File

@ -8,7 +8,6 @@
mod different_lifetimes;
mod find_anon_type;
mod named_anon_conflict;
mod outlives_closure;
mod placeholder_error;
mod static_impl_trait;
mod trait_impl_difference;
@ -57,7 +56,6 @@ pub fn try_report(&self) -> Option<ErrorReported> {
ErrorReported
})
.or_else(|| self.try_report_anon_anon_conflict())
.or_else(|| self.try_report_outlives_closure())
.or_else(|| self.try_report_static_impl_trait())
.or_else(|| self.try_report_impl_not_conforming_to_trait())
}

117
src/librustc_infer/infer/error_reporting/nice_region_error/outlives_closure.rs
View File

@ -1,117 +0,0 @@
//! Error Reporting for Anonymous Region Lifetime Errors
//! where both the regions are anonymous.
use crate::infer::error_reporting::nice_region_error::NiceRegionError;
use crate::infer::lexical_region_resolve::RegionResolutionError::SubSupConflict;
use crate::infer::SubregionOrigin;
use rustc_errors::ErrorReported;
use rustc_hir::{Expr, ExprKind::Closure, Node};
use rustc_middle::ty::RegionKind;
impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
/// Print the error message for lifetime errors when binding escapes a closure.
///
/// Consider a case where we have
///
/// ```no_run
/// fn with_int<F>(f: F) where F: FnOnce(&isize) {
/// let x = 3;
/// f(&x);
/// }
/// fn main() {
/// let mut x = None;
/// with_int(|y| x = Some(y));
/// }
/// ```
///
/// the output will be
///
/// ```text
/// let mut x = None;
/// ----- borrowed data cannot be stored into here...
/// with_int(|y| x = Some(y));
/// --- ^ cannot be stored outside of its closure
/// |
/// ...because it cannot outlive this closure
/// ```
pub(super) fn try_report_outlives_closure(&self) -> Option<ErrorReported> {
if let Some(SubSupConflict(_, origin, ref sub_origin, _, ref sup_origin, sup_region)) =
self.error
{
// #45983: when trying to assign the contents of an argument to a binding outside of a
// closure, provide a specific message pointing this out.
if let (
&SubregionOrigin::BindingTypeIsNotValidAtDecl(ref external_span),
&RegionKind::ReFree(ref free_region),
) = (&sub_origin, sup_region)
{
let hir = &self.tcx().hir();
if let Some(def_id) = free_region.scope.as_local() {
let hir_id = hir.as_local_hir_id(def_id);
if let Node::Expr(Expr { kind: Closure(_, _, _, closure_span, None), .. }) =
hir.get(hir_id)
{
let sup_sp = sup_origin.span();
let origin_sp = origin.span();
let mut err = self.tcx().sess.struct_span_err(
sup_sp,
"borrowed data cannot be stored outside of its closure",
);
err.span_label(sup_sp, "cannot be stored outside of its closure");
if origin_sp == sup_sp || origin_sp.contains(sup_sp) {
// // sup_sp == origin.span():
//
// let mut x = None;
// ----- borrowed data cannot be stored into here...
// with_int(|y| x = Some(y));
// --- ^ cannot be stored outside of its closure
// |
// ...because it cannot outlive this closure
//
// // origin.contains(&sup_sp):
//
// let mut f: Option<&u32> = None;
// ----- borrowed data cannot be stored into here...
// closure_expecting_bound(|x: &'x u32| {
// ------------ ... because it cannot outlive this closure
// f = Some(x);
// ^ cannot be stored outside of its closure
err.span_label(
*external_span,
"borrowed data cannot be stored into here...",
);
err.span_label(
*closure_span,
"...because it cannot outlive this closure",
);
} else {
// FIXME: the wording for this case could be much improved
//
// let mut lines_to_use: Vec<&CrateId> = Vec::new();
// - cannot infer an appropriate lifetime...
// let push_id = |installed_id: &CrateId| {
// ------- ------------------------ borrowed data cannot outlive this closure
// |
// ...so that variable is valid at time of its declaration
// lines_to_use.push(installed_id);
// ^^^^^^^^^^^^ cannot be stored outside of its closure
err.span_label(origin_sp, "cannot infer an appropriate lifetime...");
err.span_label(
*external_span,
"...so that variable is valid at time of its \
declaration",
);
err.span_label(
*closure_span,
"borrowed data cannot outlive this closure",
);
}
err.emit();
return Some(ErrorReported);
}
}
}
}
None
}
}

355
src/librustc_infer/infer/error_reporting/note.rs
View File

@ -38,65 +38,12 @@ pub(super) fn note_region_origin(
let var_name = self.tcx.hir().name(upvar_id.var_path.hir_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::ClosureCapture(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,
@ -126,25 +73,12 @@ pub(super) fn note_region_origin(
),
);
}
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,
@ -231,106 +165,6 @@ pub(super) fn report_concrete_failure(
);
err
}
infer::InfStackClosure(span) => {
let mut err =
struct_span_err!(self.tcx.sess, span, E0314, "closure outlives stack frame");
note_and_explain_region(
self.tcx,
region_scope_tree,
&mut err,
"...the closure must be valid for ",
sub,
"...",
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
region_scope_tree,
&mut err,
"the reference is only valid for ",
sup,
"",
);
err
}
infer::ClosureCapture(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)
);
note_and_explain_region(
self.tcx,
region_scope_tree,
&mut err,
"captured variable is valid for ",
sup,
"",
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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,
@ -407,61 +241,6 @@ pub(super) fn report_concrete_failure(
);
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)
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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,
@ -480,140 +259,6 @@ pub(super) fn report_concrete_failure(
);
err
}
infer::Operand(span) => {
let mut err = struct_span_err!(
self.tcx.sess,
span,
E0483,
"lifetime of operand does not outlive the \
operation"
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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)
);
note_and_explain_region(
self.tcx,
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
note_and_explain_region(
self.tcx,
region_scope_tree,
&mut err,
"superregion: ",
sup,
"",
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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"
);
note_and_explain_region(
self.tcx,
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,

62
src/librustc_infer/infer/mod.rs
View File

@ -378,22 +378,6 @@ pub enum SubregionOrigin<'tcx> {
/// Arose from a subtyping relation
Subtype(Box<TypeTrace<'tcx>>),
/// Stack-allocated closures cannot outlive innermost loop
/// or function so as to ensure we only require finite stack
InfStackClosure(Span),
/// Invocation of closure must be within its lifetime
InvokeClosure(Span),
/// Dereference of reference must be within its lifetime
DerefPointer(Span),
/// Closure bound must not outlive captured variables
ClosureCapture(Span, hir::HirId),
/// Index into slice must be within its lifetime
IndexSlice(Span),
/// When casting `&'a T` to an `&'b Trait` object,
/// relating `'a` to `'b`
RelateObjectBound(Span),
@ -406,10 +390,6 @@ pub enum SubregionOrigin<'tcx> {
/// that must outlive some other region.
RelateRegionParamBound(Span),
/// A bound placed on type parameters that states that must outlive
/// the moment of their instantiation.
RelateDefaultParamBound(Span, Ty<'tcx>),
/// Creating a pointer `b` to contents of another reference
Reborrow(Span),
@ -422,36 +402,9 @@ pub enum SubregionOrigin<'tcx> {
/// (&'a &'b T) where a >= b
ReferenceOutlivesReferent(Ty<'tcx>, Span),
/// Type or region parameters must be in scope.
ParameterInScope(ParameterOrigin, Span),
/// The type T of an expression E must outlive the lifetime for E.
ExprTypeIsNotInScope(Ty<'tcx>, Span),
/// A `ref b` whose region does not enclose the decl site
BindingTypeIsNotValidAtDecl(Span),
/// Regions appearing in a method receiver must outlive method call
CallRcvr(Span),
/// Regions appearing in a function argument must outlive func call
CallArg(Span),
/// Region in return type of invoked fn must enclose call
CallReturn(Span),
/// Operands must be in scope
Operand(Span),
/// Region resulting from a `&` expr must enclose the `&` expr
AddrOf(Span),
/// An auto-borrow that does not enclose the expr where it occurs
AutoBorrow(Span),
/// Region constraint arriving from destructor safety
SafeDestructor(Span),
/// Comparing the signature and requirements of an impl method against
/// the containing trait.
CompareImplMethodObligation {
@ -1809,29 +1762,14 @@ impl<'tcx> SubregionOrigin<'tcx> {
pub fn span(&self) -> Span {
match *self {
Subtype(ref a) => a.span(),
InfStackClosure(a) => a,
InvokeClosure(a) => a,
DerefPointer(a) => a,
ClosureCapture(a, _) => a,
IndexSlice(a) => a,
RelateObjectBound(a) => a,
RelateParamBound(a, _) => a,
RelateRegionParamBound(a) => a,
RelateDefaultParamBound(a, _) => a,
Reborrow(a) => a,
ReborrowUpvar(a, _) => a,
DataBorrowed(_, a) => a,
ReferenceOutlivesReferent(_, a) => a,
ParameterInScope(_, a) => a,
ExprTypeIsNotInScope(_, a) => a,
BindingTypeIsNotValidAtDecl(a) => a,
CallRcvr(a) => a,
CallArg(a) => a,
CallReturn(a) => a,
Operand(a) => a,
AddrOf(a) => a,
AutoBorrow(a) => a,
SafeDestructor(a) => a,
CompareImplMethodObligation { span, .. } => span,
}
}