nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introduce ReError

Browse Source 
CC #69314
This commit is contained in:
Esteban Küber 2023-02-03 23:21:56 +00:00
parent c40919b7a7
commit 30cf7a3f51
51 changed files with 208 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
compiler/rustc_borrowck/src/diagnostics/region_name.rs
View File

@ -343,11 +343,11 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
let note = match closure_kind_ty.to_opt_closure_kind() {
Some(ty::ClosureKind::Fn) => {
"closure implements `Fn`, so references to captured variables \
can't escape the closure"
can't escape the closure"
}
Some(ty::ClosureKind::FnMut) => {
"closure implements `FnMut`, so references to captured variables \
can't escape the closure"
can't escape the closure"
}
Some(ty::ClosureKind::FnOnce) => {
bug!("BrEnv in a `FnOnce` closure");
@ -364,7 +364,11 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
ty::BoundRegionKind::BrAnon(..) => None,
},
ty::ReLateBound(..) | ty::ReVar(..) | ty::RePlaceholder(..) | ty::ReErased => None,
ty::ReLateBound(..)
| ty::ReVar(..)
| ty::RePlaceholder(..)
| ty::ReErased
| ty::ReError => None,
}
}

2
compiler/rustc_borrowck/src/region_infer/opaque_types.rs
View File

@ -95,7 +95,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
concrete_type.span,
"opaque type with non-universal region substs",
);
infcx.tcx.lifetimes.re_static
infcx.tcx.lifetimes.re_error
}
}
};

2
compiler/rustc_borrowck/src/universal_regions.rs
View File

@ -821,6 +821,8 @@ impl<'tcx> UniversalRegionIndices<'tcx> {
pub fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
if let ty::ReVar(..) = *r {
r.to_region_vid()
} else if let ty::ReError = *r {
RegionVid::new(0)
} else {
*self
.indices

12
compiler/rustc_hir_analysis/src/astconv/mod.rs
View File

@ -264,10 +264,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
// reported an error in this case -- but if
// not, let's error out.
tcx.sess.delay_span_bug(lifetime.ident.span, "unelided lifetime in signature");
// Supply some dummy value. We don't have an
// `re_error`, annoyingly, so use `'static`.
tcx.lifetimes.re_static
tcx.lifetimes.re_error
})
}
}
@ -482,10 +479,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
// This indicates an illegal lifetime in a non-assoc-trait position
tcx.sess.delay_span_bug(self.span, "unelided lifetime in signature");
// Supply some dummy value. We don't have an
// `re_error`, annoyingly, so use `'static`.
tcx.lifetimes.re_static
tcx.lifetimes.re_error
})
.into(),
GenericParamDefKind::Type { has_default, .. } => {
@ -1629,7 +1623,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
} else {
err.emit();
}
tcx.lifetimes.re_static
tcx.lifetimes.re_error
})
}
})

2
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View File

@ -792,7 +792,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
return_span,
"expected ReFree to map to ReEarlyBound"
);
return tcx.lifetimes.re_static;
return tcx.lifetimes.re_error;
};
tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
def_id: e.def_id,

2
compiler/rustc_hir_analysis/src/collect/type_of.rs
View File

@ -928,7 +928,7 @@ fn infer_placeholder_type<'a>(
// Typeck doesn't expect erased regions to be returned from `type_of`.
tcx.fold_regions(ty, |r, _| match *r {
ty::ReErased => tcx.lifetimes.re_static,
ty::ReErased | ty::ReError => tcx.lifetimes.re_static,
_ => r,
})
}

2
compiler/rustc_hir_analysis/src/outlives/utils.rs
View File

@ -170,6 +170,8 @@ fn is_free_region(region: Region<'_>) -> bool {
// ignore it. We can't put it on the struct header anyway.
ty::ReLateBound(..) => false,
ty::ReError => false,
// These regions don't appear in types from type declarations:
ty::ReErased | ty::ReVar(..) | ty::RePlaceholder(..) | ty::ReFree(..) => {
bug!("unexpected region in outlives inference: {:?}", region);

2
compiler/rustc_hir_analysis/src/variance/constraints.rs
View File

@ -409,6 +409,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
// way early-bound regions do, so we skip them here.
}
ty::ReError => {}
ty::ReFree(..) | ty::ReVar(..) | ty::RePlaceholder(..) | ty::ReErased => {
// We don't expect to see anything but 'static or bound
// regions when visiting member types or method types.

2
compiler/rustc_infer/src/errors/note_and_explain.rs
View File

@ -31,6 +31,8 @@ impl<'a> DescriptionCtx<'a> {
ty::RePlaceholder(_) => return None,
ty::ReError => return None,
// FIXME(#13998) RePlaceholder should probably print like
// ReFree rather than dumping Debug output on the user.
//

1
compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
View File

@ -371,6 +371,7 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for Canonicalizer<'cx, 'tcx> {
ty::ReStatic
| ty::ReEarlyBound(..)
| ty::ReError
| ty::ReFree(_)
| ty::RePlaceholder(..)
| ty::ReErased => self.canonicalize_mode.canonicalize_free_region(self, r),

6
compiler/rustc_infer/src/infer/combine.rs
View File

@ -705,6 +705,10 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
return Ok(r);
}
ty::ReError => {
return Ok(r);
}
ty::RePlaceholder(..)
| ty::ReVar(..)
| ty::ReStatic
@ -861,7 +865,7 @@ impl<'tcx> FallibleTypeFolder<'tcx> for ConstInferUnifier<'_, 'tcx> {
match *r {
// Never make variables for regions bound within the type itself,
// nor for erased regions.
ty::ReLateBound(..) | ty::ReErased => {
ty::ReLateBound(..) | ty::ReErased | ty::ReError => {
return Ok(r);
}

17
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View File

@ -134,6 +134,8 @@ pub(super) fn note_and_explain_region<'tcx>(
ty::RePlaceholder(_) => return,
ty::ReError => return,
// FIXME(#13998) RePlaceholder should probably print like
// ReFree rather than dumping Debug output on the user.
//
@ -313,6 +315,9 @@ pub fn unexpected_hidden_region_diagnostic<'tcx>(
)
}
}
ty::ReError => {
err.delay_as_bug();
}
_ => {
// Ugh. This is a painful case: the hidden region is not one
// that we can easily summarize or explain. This can happen
@ -2546,7 +2551,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
);
err.note_expected_found(&"", sup_expected, &"", sup_found);
err.emit();
if sub_region.is_error() | sup_region.is_error() {
err.delay_as_bug();
} else {
err.emit();
}
return;
}
@ -2562,7 +2571,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
);
self.note_region_origin(&mut err, &sub_origin);
err.emit();
if sub_region.is_error() | sup_region.is_error() {
err.delay_as_bug();
} else {
err.emit();
}
}
/// Determine whether an error associated with the given span and definition

6
compiler/rustc_infer/src/infer/error_reporting/note.rs
View File

@ -78,7 +78,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
sub: Region<'tcx>,
sup: Region<'tcx>,
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> {
match origin {
let mut err = match origin {
infer::Subtype(box trace) => {
let terr = TypeError::RegionsDoesNotOutlive(sup, sub);
let mut err = self.report_and_explain_type_error(trace, terr);
@ -299,7 +299,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
);
err
}
};
if sub.is_error() || sup.is_error() {
err.delay_as_bug();
}
err
}
pub fn suggest_copy_trait_method_bounds(

1
compiler/rustc_infer/src/infer/freshen.rs
View File

@ -126,6 +126,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
| ty::ReFree(_)
| ty::ReVar(_)
| ty::RePlaceholder(..)
| ty::ReError
| ty::ReErased => {
// replace all free regions with 'erased
self.tcx().lifetimes.re_erased

12
compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
View File

@ -17,7 +17,7 @@ use rustc_index::vec::{Idx, IndexVec};
use rustc_middle::ty::fold::TypeFoldable;
use rustc_middle::ty::PlaceholderRegion;
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_middle::ty::{ReEarlyBound, ReErased, ReFree, ReStatic};
use rustc_middle::ty::{ReEarlyBound, ReErased, ReError, ReFree, ReStatic};
use rustc_middle::ty::{ReLateBound, RePlaceholder, ReVar};
use rustc_middle::ty::{Region, RegionVid};
use rustc_span::Span;
@ -211,7 +211,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
);
}
ReStatic => {
ReStatic | ReError => {
// nothing lives longer than `'static`
Ok(self.tcx().lifetimes.re_static)
}
@ -436,7 +436,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
}
(VarValue::Value(a), VarValue::Empty(_)) => {
match *a {
ReLateBound(..) | ReErased => {
ReLateBound(..) | ReErased | ReError => {
bug!("cannot relate region: {:?}", a);
}
@ -465,7 +465,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
}
(VarValue::Empty(a_ui), VarValue::Value(b)) => {
match *b {
ReLateBound(..) | ReErased => {
ReLateBound(..) | ReErased | ReError => {
bug!("cannot relate region: {:?}", b);
}
@ -546,6 +546,8 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
);
}
(ReError, _) | (_, ReError) => self.tcx().lifetimes.re_error,
(ReStatic, _) | (_, ReStatic) => {
// nothing lives longer than `'static`
self.tcx().lifetimes.re_static
@ -1040,7 +1042,7 @@ impl<'tcx> LexicalRegionResolutions<'tcx> {
ty::ReVar(rid) => match self.values[rid] {
VarValue::Empty(_) => r,
VarValue::Value(r) => r,
VarValue::ErrorValue => tcx.lifetimes.re_static,
VarValue::ErrorValue => tcx.lifetimes.re_error,
},
_ => r,
};

2
compiler/rustc_infer/src/infer/region_constraints/mod.rs
View File

@ -696,7 +696,7 @@ impl<'tcx> RegionConstraintCollector<'_, 'tcx> {
pub fn universe(&self, region: Region<'tcx>) -> ty::UniverseIndex {
match *region {
ty::ReStatic | ty::ReErased | ty::ReFree(..) | ty::ReEarlyBound(..) => {
ty::ReStatic | ty::ReErased | ty::ReFree(..) | ty::ReEarlyBound(..) | ty::ReError => {
ty::UniverseIndex::ROOT
}
ty::RePlaceholder(placeholder) => placeholder.universe,

9
compiler/rustc_middle/src/ty/context.rs
View File

@ -275,6 +275,9 @@ pub struct CommonLifetimes<'tcx> {
/// Erased region, used outside of type inference.
pub re_erased: Region<'tcx>,
/// Error region, used only for error reporting.
pub re_error: Region<'tcx>,
}
pub struct CommonConsts<'tcx> {
@ -324,7 +327,11 @@ impl<'tcx> CommonLifetimes<'tcx> {
))
};
CommonLifetimes { re_static: mk(ty::ReStatic), re_erased: mk(ty::ReErased) }
CommonLifetimes {
re_static: mk(ty::ReStatic),
re_erased: mk(ty::ReErased),
re_error: mk(ty::ReError),
}
}
}

2
compiler/rustc_middle/src/ty/generics.rs
View File

@ -100,7 +100,7 @@ impl GenericParamDef {
preceding_substs: &[ty::GenericArg<'tcx>],
) -> ty::GenericArg<'tcx> {
match &self.kind {
ty::GenericParamDefKind::Lifetime => tcx.lifetimes.re_static.into(),
ty::GenericParamDefKind::Lifetime => tcx.lifetimes.re_error.into(),
ty::GenericParamDefKind::Type { .. } => tcx.ty_error().into(),
ty::GenericParamDefKind::Const { .. } => {
tcx.const_error(tcx.bound_type_of(self.def_id).subst(tcx, preceding_substs)).into()

6
compiler/rustc_middle/src/ty/opaque_types.rs
View File

@ -109,6 +109,8 @@ impl<'tcx> TypeFolder<'tcx> for ReverseMapper<'tcx> {
// them.
ty::ReErased => return r,
ty::ReError => return r,
// The regions that we expect from borrow checking.
ty::ReEarlyBound(_) | ty::ReFree(_) => {}
@ -132,13 +134,13 @@ impl<'tcx> TypeFolder<'tcx> for ReverseMapper<'tcx> {
self.span,
format!(
"lifetime `{}` is part of concrete type but not used in \
parameter list of the `impl Trait` type alias",
parameter list of the `impl Trait` type alias",
r
),
)
.emit();
self.tcx().lifetimes.re_static
self.tcx().lifetimes.re_error
}
}
}

3
compiler/rustc_middle/src/ty/print/pretty.rs
View File

@ -2114,7 +2114,7 @@ impl<'tcx> PrettyPrinter<'tcx> for FmtPrinter<'_, 'tcx> {
ty::ReVar(_) if identify_regions => true,
ty::ReVar(_) | ty::ReErased => false,
ty::ReVar(_) | ty::ReErased | ty::ReError => false,
ty::ReStatic => true,
}
@ -2194,6 +2194,7 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
}
ty::ReVar(_) => {}
ty::ReErased => {}
ty::ReError => {}
ty::ReStatic => {
p!("'static");
return Ok(self);

7
compiler/rustc_middle/src/ty/sty.rs
View File

@ -1623,9 +1623,15 @@ impl<'tcx> Region<'tcx> {
ty::ReVar(..) => false,
ty::RePlaceholder(placeholder) => placeholder.name.is_named(),
ty::ReErased => false,
ty::ReError => false,
}
}
#[inline]
pub fn is_error(self) -> bool {
matches!(*self, ty::ReError)
}
#[inline]
pub fn is_static(self) -> bool {
matches!(*self, ty::ReStatic)
@ -1686,6 +1692,7 @@ impl<'tcx> Region<'tcx> {
ty::ReErased => {
flags = flags | TypeFlags::HAS_RE_ERASED;
}
ty::ReError => {}
}
debug!("type_flags({:?}) = {:?}", self, flags);

1
compiler/rustc_resolve/src/late.rs
View File

@ -1725,7 +1725,6 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
!segment.has_generic_args,
elided_lifetime_span,
);
err.note("assuming a `'static` lifetime...");
err.emit();
should_lint = false;

1
compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs
View File

@ -299,6 +299,7 @@ fn encode_region<'tcx>(
RegionKind::ReEarlyBound(..)
| RegionKind::ReFree(..)
| RegionKind::ReStatic
| RegionKind::ReError
| RegionKind::ReVar(..)
| RegionKind::RePlaceholder(..) => {
bug!("encode_region: unexpected `{:?}`", region.kind());

3
compiler/rustc_traits/src/chalk/lowering.rs
View File

@ -493,6 +493,9 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::Lifetime<RustInterner<'tcx>>> for Region<'t
ty::ReEarlyBound(_) => {
panic!("Should have already been substituted.");
}
ty::ReError => {
panic!("Error lifetime should not have already been lowered.");
}
ty::ReLateBound(db, br) => chalk_ir::LifetimeData::BoundVar(chalk_ir::BoundVar::new(
chalk_ir::DebruijnIndex::new(db.as_u32()),
br.var.as_usize(),

12
compiler/rustc_type_ir/src/sty.rs
View File

@ -960,6 +960,9 @@ pub enum RegionKind<I: Interner> {
/// Erased region, used by trait selection, in MIR and during codegen.
ReErased,
/// A region that resulted from some other error. Used exclusively for diagnostics.
ReError,
}
// This is manually implemented for `RegionKind` because `std::mem::discriminant`
@ -974,6 +977,7 @@ const fn regionkind_discriminant<I: Interner>(value: &RegionKind<I>) -> usize {
ReVar(_) => 4,
RePlaceholder(_) => 5,
ReErased => 6,
ReError => 7,
}
}
@ -999,6 +1003,7 @@ impl<I: Interner> Clone for RegionKind<I> {
ReVar(r) => ReVar(r.clone()),
RePlaceholder(r) => RePlaceholder(r.clone()),
ReErased => ReErased,
ReError => ReError,
}
}
}
@ -1077,6 +1082,7 @@ impl<I: Interner> hash::Hash for RegionKind<I> {
ReVar(r) => r.hash(state),
RePlaceholder(r) => r.hash(state),
ReErased => (),
ReError => (),
}
}
}
@ -1100,6 +1106,8 @@ impl<I: Interner> fmt::Debug for RegionKind<I> {
RePlaceholder(placeholder) => write!(f, "RePlaceholder({placeholder:?})"),
ReErased => f.write_str("ReErased"),
ReError => f.write_str("ReError"),
}
}
}
@ -1134,6 +1142,7 @@ where
a.encode(e);
}),
ReErased => e.emit_enum_variant(disc, |_| {}),
ReError => e.emit_enum_variant(disc, |_| {}),
}
}
}
@ -1156,6 +1165,7 @@ where
4 => ReVar(Decodable::decode(d)),
5 => RePlaceholder(Decodable::decode(d)),
6 => ReErased,
7 => ReError,
_ => panic!(
"{}",
format!(
@ -1184,7 +1194,7 @@ where
) {
std::mem::discriminant(self).hash_stable(hcx, hasher);
match self {
ReErased | ReStatic => {
ReErased | ReStatic | ReError => {
// No variant fields to hash for these ...
}
ReLateBound(d, r) => {

1
src/librustdoc/clean/mod.rs
View File

@ -242,6 +242,7 @@ pub(crate) fn clean_middle_region<'tcx>(region: ty::Region<'tcx>) -> Option<Life
ty::ReLateBound(..)
| ty::ReFree(..)
| ty::ReVar(..)
| ty::ReError
| ty::RePlaceholder(..)
| ty::ReErased => {
debug!("cannot clean region {:?}", region);

4
tests/ui/associated-type-bounds/elision.stderr
View File

@ -16,10 +16,10 @@ error[E0308]: mismatched types
LL | fn f(x: &mut dyn Iterator<Item: Iterator<Item = &'_ ()>>) -> Option<&'_ ()> { x.next() }
| ----------------------------- -------------- ^^^^^^^^ expected `Option<&()>`, found `Option<impl Iterator<Item = &'_ ()>>`
| | |
| | expected `Option<&'static ()>` because of return type
| | expected `Option<&()>` because of return type
| this type parameter
|
= note: expected enum `Option<&'static ()>`
= note: expected enum `Option<&()>`
found enum `Option<impl Iterator<Item = &'_ ()>>`
error: aborting due to 2 previous errors

1
tests/ui/async-await/async-fn-path-elision.stderr
View File

@ -4,7 +4,6 @@ error[E0726]: implicit elided lifetime not allowed here
LL | async fn error(lt: HasLifetime) {
| ^^^^^^^^^^^ expected lifetime parameter
|
= note: assuming a `'static` lifetime...
help: indicate the anonymous lifetime
|
LL | async fn error(lt: HasLifetime<'_>) {

10
tests/ui/const-generics/const-param-elided-lifetime.min.stderr
View File

@ -28,7 +28,7 @@ error[E0637]: `&` without an explicit lifetime name cannot be used here
LL | fn bar<const N: &u8>() {}
| ^ explicit lifetime name needed here
error: `&'static u8` is forbidden as the type of a const generic parameter
error: `&u8` is forbidden as the type of a const generic parameter
--> $DIR/const-param-elided-lifetime.rs:9:19
|
LL | struct A<const N: &u8>;
@ -37,7 +37,7 @@ LL | struct A<const N: &u8>;
= note: the only supported types are integers, `bool` and `char`
= help: more complex types are supported with `#![feature(adt_const_params)]`
error: `&'static u8` is forbidden as the type of a const generic parameter
error: `&u8` is forbidden as the type of a const generic parameter
--> $DIR/const-param-elided-lifetime.rs:14:15
|
LL | impl<const N: &u8> A<N> {
@ -46,7 +46,7 @@ LL | impl<const N: &u8> A<N> {
= note: the only supported types are integers, `bool` and `char`
= help: more complex types are supported with `#![feature(adt_const_params)]`
error: `&'static u8` is forbidden as the type of a const generic parameter
error: `&u8` is forbidden as the type of a const generic parameter
--> $DIR/const-param-elided-lifetime.rs:22:15
|
LL | impl<const N: &u8> B for A<N> {}
@ -55,7 +55,7 @@ LL | impl<const N: &u8> B for A<N> {}
= note: the only supported types are integers, `bool` and `char`
= help: more complex types are supported with `#![feature(adt_const_params)]`
error: `&'static u8` is forbidden as the type of a const generic parameter
error: `&u8` is forbidden as the type of a const generic parameter
--> $DIR/const-param-elided-lifetime.rs:26:17
|
LL | fn bar<const N: &u8>() {}
@ -64,7 +64,7 @@ LL | fn bar<const N: &u8>() {}
= note: the only supported types are integers, `bool` and `char`
= help: more complex types are supported with `#![feature(adt_const_params)]`
error: `&'static u8` is forbidden as the type of a const generic parameter
error: `&u8` is forbidden as the type of a const generic parameter
--> $DIR/const-param-elided-lifetime.rs:17:21
|
LL | fn foo<const M: &u8>(&self) {}

10
tests/ui/const-generics/const-param-elided-lifetime.rs
View File

@ -8,23 +8,23 @@
struct A<const N: &u8>;
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//[min]~^^ ERROR `&'static u8` is forbidden
//[min]~^^ ERROR `&u8` is forbidden
trait B {}
impl<const N: &u8> A<N> {
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//[min]~^^ ERROR `&'static u8` is forbidden
//[min]~^^ ERROR `&u8` is forbidden
fn foo<const M: &u8>(&self) {}
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//[min]~^^ ERROR `&'static u8` is forbidden
//[min]~^^ ERROR `&u8` is forbidden
}
impl<const N: &u8> B for A<N> {}
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//[min]~^^ ERROR `&'static u8` is forbidden
//[min]~^^ ERROR `&u8` is forbidden
fn bar<const N: &u8>() {}
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//[min]~^^ ERROR `&'static u8` is forbidden
//[min]~^^ ERROR `&u8` is forbidden
fn main() {}

2
tests/ui/const-generics/issues/issue-56445-1.min.stderr
View File

@ -6,7 +6,7 @@ LL | struct Bug<'a, const S: &'a str>(PhantomData<&'a ()>);
|
= note: for more information, see issue #74052 <https://github.com/rust-lang/rust/issues/74052>
error: `&'static str` is forbidden as the type of a const generic parameter
error: `&str` is forbidden as the type of a const generic parameter
--> $DIR/issue-56445-1.rs:9:25
|
LL | struct Bug<'a, const S: &'a str>(PhantomData<&'a ()>);

2
tests/ui/const-generics/issues/issue-56445-1.rs
View File

@ -8,6 +8,6 @@ use std::marker::PhantomData;
struct Bug<'a, const S: &'a str>(PhantomData<&'a ()>);
//~^ ERROR: use of non-static lifetime `'a` in const generic
//[min]~| ERROR: `&'static str` is forbidden as the type of a const generic parameter
//[min]~| ERROR: `&str` is forbidden as the type of a const generic parameter
impl Bug<'_, ""> {}

1
tests/ui/generics/issue-65285-incorrect-explicit-lifetime-name-needed.rs
View File

@ -8,7 +8,6 @@ fn should_error<T>() where T : Into<&u32> {}
trait X<'a, K: 'a> {
fn foo<'b, L: X<&'b Nested<K>>>();
//~^ ERROR missing lifetime specifier [E0106]
//~| ERROR the type `&'b Nested<K>` does not fulfill the required lifetime
}
fn bar<'b, L: X<&'b Nested<i32>>>(){}

18
tests/ui/generics/issue-65285-incorrect-explicit-lifetime-name-needed.stderr
View File

@ -29,7 +29,7 @@ LL | fn foo<'b, L: X<'lifetime, &'b Nested<K>>>();
| ++++++++++
error[E0106]: missing lifetime specifier
--> $DIR/issue-65285-incorrect-explicit-lifetime-name-needed.rs:14:16
--> $DIR/issue-65285-incorrect-explicit-lifetime-name-needed.rs:13:16
|
LL | fn bar<'b, L: X<&'b Nested<i32>>>(){}
| ^ expected named lifetime parameter
@ -39,19 +39,7 @@ help: consider using the `'b` lifetime
LL | fn bar<'b, L: X<'b, &'b Nested<i32>>>(){}
| +++
error[E0477]: the type `&'b Nested<K>` does not fulfill the required lifetime
--> $DIR/issue-65285-incorrect-explicit-lifetime-name-needed.rs:9:19
|
LL | fn foo<'b, L: X<&'b Nested<K>>>();
| ^^^^^^^^^^^^^^^^
|
note: type must satisfy the static lifetime as required by this binding
--> $DIR/issue-65285-incorrect-explicit-lifetime-name-needed.rs:8:16
|
LL | trait X<'a, K: 'a> {
| ^^
error: aborting due to 3 previous errors
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0106, E0477, E0637.
Some errors have detailed explanations: E0106, E0637.
For more information about an error, try `rustc --explain E0106`.

1
tests/ui/impl-header-lifetime-elision/path-elided.stderr
View File

@ -4,7 +4,6 @@ error[E0726]: implicit elided lifetime not allowed here
LL | impl MyTrait for Foo {
| ^^^ expected lifetime parameter
|
= note: assuming a `'static` lifetime...
help: indicate the anonymous lifetime
|
LL | impl MyTrait for Foo<'_> {

1
tests/ui/impl-header-lifetime-elision/trait-elided.stderr
View File

@ -4,7 +4,6 @@ error[E0726]: implicit elided lifetime not allowed here
LL | impl MyTrait for u32 {}
| ^^^^^^^ expected lifetime parameter
|
= note: assuming a `'static` lifetime...
help: indicate the anonymous lifetime
|
LL | impl MyTrait<'_> for u32 {}

4
tests/ui/impl-trait/in-trait/signature-mismatch.stderr
View File

@ -2,12 +2,12 @@ error: `impl` item signature doesn't match `trait` item signature
--> $DIR/signature-mismatch.rs:15:5
|
LL | fn async_fn(&self, buff: &[u8]) -> impl Future<Output = Vec<u8>>;
| ----------------------------------------------------------------- expected `fn(&'1 Struct, &'2 [u8]) -> impl Future<Output = Vec<u8>> + 'static`
| ----------------------------------------------------------------- expected `fn(&'1 Struct, &'2 [u8]) -> impl Future<Output = Vec<u8>> + '3`
...
LL | fn async_fn<'a>(&self, buff: &'a [u8]) -> impl Future<Output = Vec<u8>> + 'a {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 Struct, &'2 [u8]) -> impl Future<Output = Vec<u8>> + '2`
|
= note: expected signature `fn(&'1 Struct, &'2 [u8]) -> impl Future<Output = Vec<u8>> + 'static`
= note: expected signature `fn(&'1 Struct, &'2 [u8]) -> impl Future<Output = Vec<u8>> + '3`
found signature `fn(&'1 Struct, &'2 [u8]) -> impl Future<Output = Vec<u8>> + '2`
= help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait`
= help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output

10
tests/ui/inference/issue-107090.rs
View File

@ -2,9 +2,7 @@ use std::marker::PhantomData;
struct Foo<'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>)
where
Foo<'short, 'out, T>: Convert<'a, 'b>;
//~^ ERROR mismatched types
//~^^ ERROR mismatched types
//~^^^ ERROR use of undeclared lifetime name
//~^ ERROR use of undeclared lifetime name
//~| ERROR use of undeclared lifetime name `'out`
trait Convert<'a, 'b>: Sized {
@ -13,19 +11,15 @@ trait Convert<'a, 'b>: Sized {
impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
//~^ ERROR use of undeclared lifetime name
//~^^ ERROR use of undeclared lifetime name `'out`
//~| ERROR cannot infer an appropriate lifetime for lifetime parameter
fn cast(&'long self) -> &'short Foo<'short, 'out, T> {
//~^ ERROR use of undeclared lifetime name
//~| ERROR cannot infer an appropriate lifetime for lifetime parameter
self
}
}
fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T {
//~^ ERROR use of undeclared lifetime name
//~^^ ERROR incompatible lifetime on type
//~| ERROR `x` has lifetime `'in_` but it needs to satisfy a `'static` lifetime requirement
sadness.cast()
sadness.cast() //~ ERROR mismatched types
}
fn main() {}

115
tests/ui/inference/issue-107090.stderr
View File

@ -30,7 +30,7 @@ LL | struct Foo<'out, 'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>)
| +++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/issue-107090.rs:13:47
--> $DIR/issue-107090.rs:11:47
|
LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
| - ^^ undeclared lifetime
@ -38,13 +38,13 @@ LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T>
| help: consider introducing lifetime `'b` here: `'b,`
error[E0261]: use of undeclared lifetime name `'out`
--> $DIR/issue-107090.rs:13:67
--> $DIR/issue-107090.rs:11:67
|
LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
| - help: consider introducing lifetime `'out` here: `'out,` ^^^^ undeclared lifetime
error[E0261]: use of undeclared lifetime name `'out`
--> $DIR/issue-107090.rs:17:49
--> $DIR/issue-107090.rs:14:49
|
LL | fn cast(&'long self) -> &'short Foo<'short, 'out, T> {
| ^^^^ undeclared lifetime
@ -59,7 +59,7 @@ LL | impl<'out, 'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'ou
| +++++
error[E0261]: use of undeclared lifetime name `'short`
--> $DIR/issue-107090.rs:24:68
--> $DIR/issue-107090.rs:20:68
|
LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T {
| - ^^^^^^ undeclared lifetime
@ -67,107 +67,18 @@ LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short,
| help: consider introducing lifetime `'short` here: `'short,`
error[E0308]: mismatched types
--> $DIR/issue-107090.rs:4:27
|
LL | Foo<'short, 'out, T>: Convert<'a, 'b>;
| ^^^^^^^^^^^^^^^ lifetime mismatch
|
= note: expected trait `Convert<'static, 'static>`
found trait `Convert<'a, 'b>`
note: the lifetime `'a` as defined here...
--> $DIR/issue-107090.rs:2:12
|
LL | struct Foo<'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>)
| ^^
= note: ...does not necessarily outlive the static lifetime
error[E0308]: mismatched types
--> $DIR/issue-107090.rs:4:27
|
LL | Foo<'short, 'out, T>: Convert<'a, 'b>;
| ^^^^^^^^^^^^^^^ lifetime mismatch
|
= note: expected trait `Convert<'static, 'static>`
found trait `Convert<'a, 'b>`
note: the lifetime `'b` as defined here...
--> $DIR/issue-107090.rs:2:16
|
LL | struct Foo<'a, 'b, T>(PhantomData<(&'a (), &'b (), T)>)
| ^^
= note: ...does not necessarily outlive the static lifetime
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'long` due to conflicting requirements
--> $DIR/issue-107090.rs:13:55
|
LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
| ^^^^^^^^^^^^^^^^^^^^
|
note: first, the lifetime cannot outlive the lifetime `'short` as defined here...
--> $DIR/issue-107090.rs:13:21
|
LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
| ^^^^^^
= note: ...but the lifetime must also be valid for the static lifetime...
note: ...so that the types are compatible
--> $DIR/issue-107090.rs:13:55
|
LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
| ^^^^^^^^^^^^^^^^^^^^
= note: expected `Convert<'short, 'static>`
found `Convert<'_, 'static>`
error: incompatible lifetime on type
--> $DIR/issue-107090.rs:24:29
--> $DIR/issue-107090.rs:22:5
|
LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T {
| ^^^^^^^^^^^^^^^^^^
| - this type parameter ------- expected `&'out T` because of return type
LL |
LL | sadness.cast()
| ^^^^^^^^^^^^^^ expected `&T`, found `&Foo<'_, '_, T>`
|
note: because this has an unmet lifetime requirement
--> $DIR/issue-107090.rs:4:27
|
LL | Foo<'short, 'out, T>: Convert<'a, 'b>;
| ^^^^^^^^^^^^^^^ introduces a `'static` lifetime requirement
note: the lifetime `'out` as defined here...
--> $DIR/issue-107090.rs:24:17
|
LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T {
| ^^^^
note: ...does not necessarily outlive the static lifetime introduced by the compatible `impl`
--> $DIR/issue-107090.rs:13:1
|
LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: expected reference `&'out T`
found reference `&Foo<'_, '_, T>`
error[E0759]: `x` has lifetime `'in_` but it needs to satisfy a `'static` lifetime requirement
--> $DIR/issue-107090.rs:24:29
|
LL | fn badboi<'in_, 'out, T>(x: Foo<'in_, 'out, T>, sadness: &'in_ Foo<'short, 'out, T>) -> &'out T {
| ^^^^^^^^^^^^^^^^^^
| |
| this data with lifetime `'in_`...
| ...is used and required to live as long as `'static` here
error: aborting due to 7 previous errors
error[E0495]: cannot infer an appropriate lifetime for lifetime parameter `'long` due to conflicting requirements
--> $DIR/issue-107090.rs:17:13
|
LL | fn cast(&'long self) -> &'short Foo<'short, 'out, T> {
| ^^^^^^^^^^^
|
note: first, the lifetime cannot outlive the lifetime `'short` as defined here...
--> $DIR/issue-107090.rs:13:21
|
LL | impl<'long: 'short, 'short, T> Convert<'long, 'b> for Foo<'short, 'out, T> {
| ^^^^^^
= note: ...but the lifetime must also be valid for the static lifetime...
note: ...so that the types are compatible
--> $DIR/issue-107090.rs:17:13
|
LL | fn cast(&'long self) -> &'short Foo<'short, 'out, T> {
| ^^^^^^^^^^^
= note: expected `Convert<'short, 'static>`
found `Convert<'_, 'static>`
error: aborting due to 12 previous errors
Some errors have detailed explanations: E0261, E0308, E0495, E0759.
Some errors have detailed explanations: E0261, E0308.
For more information about an error, try `rustc --explain E0261`.

1
tests/ui/issues/issue-10412.stderr
View File

@ -46,7 +46,6 @@ error[E0726]: implicit elided lifetime not allowed here
LL | impl<'self> Serializable<str> for &'self str {
| ^^^^^^^^^^^^^^^^^ expected lifetime parameter
|
= note: assuming a `'static` lifetime...
help: indicate the anonymous lifetime
|
LL | impl<'self> Serializable<'_, str> for &'self str {

4
tests/ui/lifetimes/issue-26638.stderr
View File

@ -40,9 +40,9 @@ error[E0308]: mismatched types
LL | fn parse_type(iter: Box<dyn Iterator<Item=&str>+'static>) -> &str { iter.next() }
| ---- ^^^^^^^^^^^ expected `&str`, found `Option<&str>`
| |
| expected `&'static str` because of return type
| expected `&str` because of return type
|
= note: expected reference `&'static str`
= note: expected reference `&str`
found enum `Option<&str>`
error[E0061]: this function takes 1 argument but 0 arguments were supplied

22
tests/ui/lifetimes/issue-69314.fixed Normal file
View File

@ -0,0 +1,22 @@
// run-rustfix
// edition:2021
#![allow(dead_code, unused_mut, unused_variables)]
struct A {}
struct Msg<'a> {
s: &'a [i32],
}
impl A {
async fn g(buf: &[i32]) -> Msg<'_> {
Msg { s: &buf[0..1] }
}
async fn f() {
let mut buf = [0; 512];
let m2 = &buf[..]; //~ ERROR `buf` does not live long enough
let m = Self::g(m2).await;
Self::f2(m).await;
}
async fn f2(m: Msg<'_>) {}
//~^ ERROR implicit elided lifetime not allowed here
}
fn main() {}

22
tests/ui/lifetimes/issue-69314.rs Normal file
View File

@ -0,0 +1,22 @@
// run-rustfix
// edition:2021
#![allow(dead_code, unused_mut, unused_variables)]
struct A {}
struct Msg<'a> {
s: &'a [i32],
}
impl A {
async fn g(buf: &[i32]) -> Msg<'_> {
Msg { s: &buf[0..1] }
}
async fn f() {
let mut buf = [0; 512];
let m2 = &buf[..]; //~ ERROR `buf` does not live long enough
let m = Self::g(m2).await;
Self::f2(m).await;
}
async fn f2(m: Msg) {}
//~^ ERROR implicit elided lifetime not allowed here
}
fn main() {}

26
tests/ui/lifetimes/issue-69314.stderr Normal file
View File

@ -0,0 +1,26 @@
error[E0726]: implicit elided lifetime not allowed here
--> $DIR/issue-69314.rs:18:20
|
LL | async fn f2(m: Msg) {}
| ^^^ expected lifetime parameter
|
help: indicate the anonymous lifetime
|
LL | async fn f2(m: Msg<'_>) {}
| ++++
error[E0597]: `buf` does not live long enough
--> $DIR/issue-69314.rs:14:19
|
LL | let m2 = &buf[..];
| ^^^ borrowed value does not live long enough
LL | let m = Self::g(m2).await;
| ----------- argument requires that `buf` is borrowed for `'static`
LL | Self::f2(m).await;
LL | }
| - `buf` dropped here while still borrowed
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0597, E0726.
For more information about an error, try `rustc --explain E0597`.

2
tests/ui/lifetimes/unusual-rib-combinations.rs
View File

@ -23,6 +23,6 @@ fn c<T = u8()>() {}
// Elided lifetime in path in ConstGeneric
fn d<const C: S>() {}
//~^ ERROR missing lifetime specifier
//~| ERROR `S<'static>` is forbidden as the type of a const generic parameter
//~| ERROR `S<'_>` is forbidden as the type of a const generic parameter
fn main() {}

2
tests/ui/lifetimes/unusual-rib-combinations.stderr
View File

@ -46,7 +46,7 @@ LL | fn a() -> [u8; foo::()] {
= note: expected type `usize`
found fn item `fn() {foo}`
error: `S<'static>` is forbidden as the type of a const generic parameter
error: `S<'_>` is forbidden as the type of a const generic parameter
--> $DIR/unusual-rib-combinations.rs:24:15
|
LL | fn d<const C: S>() {}

4
tests/ui/mismatched_types/issue-74918-missing-lifetime.stderr
View File

@ -16,9 +16,9 @@ LL | fn next(&mut self) -> Option<IteratorChunk<T, S>> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 mut ChunkingIterator<T, S>) -> Option<IteratorChunk<'1, T, S>>`
--> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
|
= note: expected `fn(&'1 mut ChunkingIterator<T, S>) -> Option<IteratorChunk<'static, T, S>>`
= note: expected `fn(&'1 mut ChunkingIterator<T, S>) -> Option<IteratorChunk<'2, T, S>>`
|
= note: expected signature `fn(&'1 mut ChunkingIterator<T, S>) -> Option<IteratorChunk<'static, T, S>>`
= note: expected signature `fn(&'1 mut ChunkingIterator<T, S>) -> Option<IteratorChunk<'2, T, S>>`
found signature `fn(&'1 mut ChunkingIterator<T, S>) -> Option<IteratorChunk<'1, T, S>>`
= help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait`
= help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output

2
tests/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.rs
View File

@ -4,7 +4,7 @@ fn main() {
let y = 42;
let x = wrong_generic(&y);
let z: i32 = x;
//~^ ERROR expected generic type parameter, found `&'static i32
//~^ ERROR expected generic type parameter, found `&i32`
}
type WrongGeneric<T> = impl 'static;

2
tests/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr
View File

@ -4,7 +4,7 @@ error: at least one trait must be specified
LL | type WrongGeneric<T> = impl 'static;
| ^^^^^^^^^^^^
error[E0792]: expected generic type parameter, found `&'static i32`
error[E0792]: expected generic type parameter, found `&i32`
--> $DIR/generic_type_does_not_live_long_enough.rs:6:18
|
LL | let z: i32 = x;

2
tests/ui/wf/wf-in-foreign-fn-decls-issue-80468.rs
View File

@ -13,5 +13,5 @@ pub struct Ref<'a>(&'a u8);
impl Trait for Ref {} //~ ERROR: implicit elided lifetime not allowed here
extern "C" {
pub fn repro(_: Wrapper<Ref>); //~ ERROR: incompatible lifetime on type
pub fn repro(_: Wrapper<Ref>);
}

25
tests/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr
View File

@ -4,34 +4,11 @@ error[E0726]: implicit elided lifetime not allowed here
LL | impl Trait for Ref {}
| ^^^ expected lifetime parameter
|
= note: assuming a `'static` lifetime...
help: indicate the anonymous lifetime
|
LL | impl Trait for Ref<'_> {}
| ++++
error: incompatible lifetime on type
--> $DIR/wf-in-foreign-fn-decls-issue-80468.rs:16:21
|
LL | pub fn repro(_: Wrapper<Ref>);
| ^^^^^^^^^^^^
|
note: because this has an unmet lifetime requirement
--> $DIR/wf-in-foreign-fn-decls-issue-80468.rs:8:23
|
LL | pub struct Wrapper<T: Trait>(T);
| ^^^^^ introduces a `'static` lifetime requirement
note: the anonymous lifetime as defined here...
--> $DIR/wf-in-foreign-fn-decls-issue-80468.rs:16:29
|
LL | pub fn repro(_: Wrapper<Ref>);
| ^^^
note: ...does not necessarily outlive the static lifetime introduced by the compatible `impl`
--> $DIR/wf-in-foreign-fn-decls-issue-80468.rs:13:1
|
LL | impl Trait for Ref {}
| ^^^^^^^^^^^^^^^^^^
error: aborting due to 2 previous errors
error: aborting due to previous error
For more information about this error, try `rustc --explain E0726`.