nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-13 12:36:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

always show and explain sub region

Browse Source
This commit is contained in:
Ali MJ Al-Nasrawy 2023-09-17 14:32:02 +00:00
parent 5be0b2283a
commit 996ffcb718
71 changed files with 462 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -59,8 +59,8 @@ use crate::traits::{
};
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
use rustc_errors::{error_code, Applicability, DiagnosticBuilder, DiagnosticStyledString};
use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed, IntoDiagnosticArg};
use rustc_errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
use rustc_hir as hir;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::{DefId, LocalDefId};
@ -2341,40 +2341,29 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
},
};
let mut err = match sub.kind() {
ty::ReEarlyBound(_) | ty::ReFree(_) if sub.has_name() => struct_span_err!(
self.tcx.sess,
span,
E0309,
"{} may not live long enough",
labeled_user_string
),
ty::ReStatic => struct_span_err!(
self.tcx.sess,
span,
E0310,
"{} may not live long enough",
labeled_user_string
),
_ => {
let mut err = struct_span_err!(
self.tcx.sess,
span,
E0311,
"{} may not live long enough",
labeled_user_string
);
note_and_explain_region(
self.tcx,
&mut err,
&format!("{labeled_user_string} must be valid for "),
sub,
"...",
None,
);
err
let mut err = self.tcx.sess.struct_span_err_with_code(
span,
format!("{labeled_user_string} may not live long enough"),
match sub.kind() {
ty::ReEarlyBound(_) | ty::ReFree(_) if sub.has_name() => error_code!(E0309),
ty::ReStatic => error_code!(E0310),
_ => error_code!(E0311),
},
);
'_explain: {
let (description, span) = match sub.kind() {
ty::ReEarlyBound(_) | ty::ReFree(_) | ty::ReStatic => {
msg_span_from_named_region(self.tcx, sub, Some(span))
}
_ => (format!("lifetime `{sub}`"), Some(span)),
};
let prefix = format!("{labeled_user_string} must be valid for ");
label_msg_span(&mut err, &prefix, description, span, "...");
if let Some(origin) = origin {
self.note_region_origin(&mut err, &origin);
}
};
}
'suggestion: {
let msg = "consider adding an explicit lifetime bound";
@ -2450,9 +2439,6 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
);
}
if let Some(origin) = origin {
self.note_region_origin(&mut err, &origin);
}
err
}

4
tests/ui/associated-inherent-types/regionck-1.stderr
View File

@ -2,7 +2,9 @@ error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regionck-1.rs:9:30
|
LL | type NoTyOutliv<'a, T> = &'a T;
| ^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
| -- ^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
| |
| the parameter type `T` must be valid for the lifetime `'a` as defined here...
|
help: consider adding an explicit lifetime bound...
|

30
tests/ui/async-await/in-trait/async-generics-and-bounds.stderr
View File

@ -2,18 +2,11 @@ error[E0311]: the parameter type `U` may not live long enough
--> $DIR/async-generics-and-bounds.rs:12:5
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| | the parameter type `U` must be valid for the anonymous lifetime as defined here...
| ...so that the reference type `&(T, U)` does not outlive the data it points at
|
note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
--> $DIR/async-generics-and-bounds.rs:12:18
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
| ^
note: ...so that the reference type `&(T, U)` does not outlive the data it points at
--> $DIR/async-generics-and-bounds.rs:12:5
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider adding an explicit lifetime bound...
|
LL | async fn foo<'a>(&'a self) -> &'a (T, U) where T: Debug + Sized, U: Hash, U: 'a;
@ -23,18 +16,11 @@ error[E0311]: the parameter type `T` may not live long enough
--> $DIR/async-generics-and-bounds.rs:12:5
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| | the parameter type `T` must be valid for the anonymous lifetime as defined here...
| ...so that the reference type `&(T, U)` does not outlive the data it points at
|
note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
--> $DIR/async-generics-and-bounds.rs:12:18
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
| ^
note: ...so that the reference type `&(T, U)` does not outlive the data it points at
--> $DIR/async-generics-and-bounds.rs:12:5
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider adding an explicit lifetime bound...
|
LL | async fn foo<'a>(&'a self) -> &'a (T, U) where T: Debug + Sized, U: Hash, T: 'a;

30
tests/ui/async-await/in-trait/async-generics.stderr
View File

@ -2,18 +2,11 @@ error[E0311]: the parameter type `U` may not live long enough
--> $DIR/async-generics.rs:9:5
|
LL | async fn foo(&self) -> &(T, U);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^
| | |
| | the parameter type `U` must be valid for the anonymous lifetime as defined here...
| ...so that the reference type `&(T, U)` does not outlive the data it points at
|
note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
--> $DIR/async-generics.rs:9:18
|
LL | async fn foo(&self) -> &(T, U);
| ^
note: ...so that the reference type `&(T, U)` does not outlive the data it points at
--> $DIR/async-generics.rs:9:5
|
LL | async fn foo(&self) -> &(T, U);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider adding an explicit lifetime bound...
|
LL | async fn foo<'a>(&'a self) -> &'a (T, U) where U: 'a;
@ -23,18 +16,11 @@ error[E0311]: the parameter type `T` may not live long enough
--> $DIR/async-generics.rs:9:5
|
LL | async fn foo(&self) -> &(T, U);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^
| | |
| | the parameter type `T` must be valid for the anonymous lifetime as defined here...
| ...so that the reference type `&(T, U)` does not outlive the data it points at
|
note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
--> $DIR/async-generics.rs:9:18
|
LL | async fn foo(&self) -> &(T, U);
| ^
note: ...so that the reference type `&(T, U)` does not outlive the data it points at
--> $DIR/async-generics.rs:9:5
|
LL | async fn foo(&self) -> &(T, U);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider adding an explicit lifetime bound...
|
LL | async fn foo<'a>(&'a self) -> &'a (T, U) where T: 'a;

5
tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/builtin-superkinds-self-type.rs:10:16
|
LL | impl <T: Sync> Foo for T { }
| ^^^ ...so that the type `T` will meet its required lifetime bounds...
| ^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/builtin-superkinds-self-type.rs:6:24

5
tests/ui/coercion/issue-53475.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-53475.rs:10:1
|
LL | impl<T> CoerceUnsized<Foo<dyn Any>> for Foo<T> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

10
tests/ui/consts/issue-102117.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-102117.rs:19:26
|
LL | type_id: TypeId::of::<T>(),
| ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-102117.rs:19:26
|
LL | type_id: TypeId::of::<T>(),
| ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: consider adding an explicit lifetime bound...

14
tests/ui/error-codes/E0311.stderr
View File

@ -1,19 +1,11 @@
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/E0311.rs:6:5
|
LL | with_restriction::<T>(x)
| ^^^^^^^^^^^^^^^^^^^^^
|
note: the parameter type `T` must be valid for the anonymous lifetime defined here...
--> $DIR/E0311.rs:5:25
|
LL | fn no_restriction<T>(x: &()) -> &() {
| ^^^
note: ...so that the type `T` will meet its required lifetime bounds
--> $DIR/E0311.rs:6:5
|
| --- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL | with_restriction::<T>(x)
| ^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {

4
tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
View File

@ -2,7 +2,9 @@ error[E0309]: the parameter type `T` may not live long enough
--> $DIR/implied-bounds-unnorm-associated-type-5.rs:6:13
|
LL | impl<'a, T> Trait<'a> for T {
| ^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
| -- ^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
| |
| the parameter type `T` must be valid for the lifetime `'a` as defined here...
|
note: ...that is required by this bound
--> $DIR/implied-bounds-unnorm-associated-type-5.rs:1:18

4
tests/ui/generic-associated-types/issue-84931.stderr
View File

@ -2,7 +2,9 @@ error[E0309]: the parameter type `T` may not live long enough
--> $DIR/issue-84931.rs:14:21
|
LL | type Item<'a> = &'a mut T;
| ^^^^^^^^^ ...so that the reference type `&'a mut T` does not outlive the data it points at
| -- ^^^^^^^^^ ...so that the reference type `&'a mut T` does not outlive the data it points at
| |
| the parameter type `T` must be valid for the lifetime `'a` as defined here...
|
help: consider adding an explicit lifetime bound...
|

5
tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr
View File

@ -117,7 +117,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/must_outlive_least_region_or_bound.rs:43:5
|
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
| ^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

5
tests/ui/impl-trait/type_parameters_captured.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/type_parameters_captured.rs:8:5
|
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
| ^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

3
tests/ui/impl-trait/unactionable_diagnostic.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/unactionable_diagnostic.rs:21:5
|
LL | pub fn bar<'t, T>(
| -- the parameter type `T` must be valid for the lifetime `'t` as defined here...
...
LL | foo(post, x)
| ^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

25
tests/ui/lifetimes/lifetime-doesnt-live-long-enough.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:19:10
|
LL | foo: &'static T
| ^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
| ^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the reference type `&'static T` does not outlive the data it points at
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,9 @@ error[E0309]: the parameter type `K` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:41:33
|
LL | fn generic_in_parent<'a, L: X<&'a Nested<K>>>() {
| ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
| -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
| |
| the parameter type `K` must be valid for the lifetime `'a` as defined here...
|
help: consider adding an explicit lifetime bound...
|
@ -24,7 +29,9 @@ error[E0309]: the parameter type `M` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:44:36
|
LL | fn generic_in_child<'a, 'b, L: X<&'a Nested<M>>, M: 'b>() {
| ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<M>` does not outlive the data it points at
| -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<M>` does not outlive the data it points at
| |
| the parameter type `M` must be valid for the lifetime `'a` as defined here...
|
help: consider adding an explicit lifetime bound...
|
@ -35,7 +42,9 @@ error[E0309]: the parameter type `K` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:24:19
|
LL | fn foo<'a, L: X<&'a Nested<K>>>();
| ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
| -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
| |
| the parameter type `K` must be valid for the lifetime `'a` as defined here...
|
help: consider adding an explicit lifetime bound...
|
@ -46,7 +55,9 @@ error[E0309]: the parameter type `Self` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:28:19
|
LL | fn bar<'a, L: X<&'a Nested<Self>>>();
| ^^^^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<Self>` does not outlive the data it points at
| -- ^^^^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<Self>` does not outlive the data it points at
| |
| the parameter type `Self` must be valid for the lifetime `'a` as defined here...
|
help: consider adding an explicit lifetime bound...
|
@ -57,7 +68,9 @@ error[E0309]: the parameter type `L` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:32:22
|
LL | fn baz<'a, L, M: X<&'a Nested<L>>>() {
| ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<L>` does not outlive the data it points at
| -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<L>` does not outlive the data it points at
| |
| the parameter type `L` must be valid for the lifetime `'a` as defined here...
|
help: consider adding an explicit lifetime bound...
|

5
tests/ui/lifetimes/lifetime-errors/issue_74400.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue_74400.rs:12:5
|
LL | f(data, identity)
| ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

14
tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr
View File

@ -1,19 +1,11 @@
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/suggest-introducing-and-adding-missing-lifetime.rs:6:5
|
LL | with_restriction::<T>(x)
| ^^^^^^^^^^^^^^^^^^^^^
|
note: the parameter type `T` must be valid for the anonymous lifetime defined here...
--> $DIR/suggest-introducing-and-adding-missing-lifetime.rs:5:25
|
LL | fn no_restriction<T>(x: &()) -> &() {
| ^^^
note: ...so that the type `T` will meet its required lifetime bounds
--> $DIR/suggest-introducing-and-adding-missing-lifetime.rs:6:5
|
| --- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL | with_restriction::<T>(x)
| ^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {

5
tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/overlapping-impl-1-modulo-regions.rs:14:21
|
LL | impl<T: Copy> F for T {}
| ^ ...so that the type `T` will meet its required lifetime bounds
| ^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

3
tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr
View File

@ -25,6 +25,9 @@ LL | | T: Trait<'a>,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/propagate-from-trait-match.rs:43:9
|
LL | fn supply<'a, T>(value: T)
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | require(value);
| ^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

4
tests/ui/nll/issue-98589-closures-relate-named-regions.stderr
View File

@ -37,6 +37,8 @@ LL | || { None::<&'a &'b ()>; };
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/issue-98589-closures-relate-named-regions.rs:26:10
|
LL | fn test_early_type<'a: 'a, T>() {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | || { None::<&'a T>; };
| ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -48,6 +50,8 @@ LL | fn test_early_type<'a: 'a, T: 'a>() {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/issue-98589-closures-relate-named-regions.rs:32:10
|
LL | fn test_late_type<'a, T>() {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | || { None::<&'a T>; };
| ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

5
tests/ui/nll/issue-98693.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-98693.rs:16:9
|
LL | assert_static::<T>();
| ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

6
tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/min-choice-reject-ambiguous.rs:17:5
|
LL | fn test_b<'a, 'b, 'c, T>() -> impl Cap<'a> + Cap<'b> + Cap<'c>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | type_test::<'_, T>() // This should pass if we pick 'b.
| ^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -12,6 +15,9 @@ LL | T: 'b + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/min-choice-reject-ambiguous.rs:28:5
|
LL | fn test_c<'a, 'b, 'c, T>() -> impl Cap<'a> + Cap<'b> + Cap<'c>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | type_test::<'_, T>() // This should pass if we pick 'c.
| ^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

6
tests/ui/nll/ty-outlives/impl-trait-outlives.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/impl-trait-outlives.rs:11:5
|
LL | fn no_region<'a, T>(x: Box<T>) -> impl Debug + 'a
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|
@ -12,6 +15,9 @@ LL | T: Debug + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/impl-trait-outlives.rs:26:5
|
LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> impl Debug + 'a
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|

5
tests/ui/nll/ty-outlives/projection-implied-bounds.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/projection-implied-bounds.rs:30:36
|
LL | twice(value, |value_ref, item| invoke2(value_ref, item));
| ^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

6
tests/ui/nll/ty-outlives/projection-no-regions-closure.stderr
View File

@ -25,6 +25,9 @@ LL | | T: Iterator,
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-closure.rs:25:31
|
LL | fn no_region<'a, T>(x: Box<T>) -> Box<dyn Anything + 'a>
| -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
...
LL | with_signature(x, |mut y| Box::new(y.next()))
| ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
|
@ -84,6 +87,9 @@ LL | | T: 'b + Iterator,
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-closure.rs:42:31
|
LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> Box<dyn Anything + 'a>
| -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
...
LL | with_signature(x, |mut y| Box::new(y.next()))
| ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
|

6
tests/ui/nll/ty-outlives/projection-no-regions-fn.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-fn.rs:13:5
|
LL | fn no_region<'a, T>(mut x: T) -> Box<dyn Anything + 'a>
| -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
...
LL | Box::new(x.next())
| ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
|
@ -12,6 +15,9 @@ LL | T: Iterator, <T as Iterator>::Item: 'a
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-fn.rs:28:5
|
LL | fn wrong_region<'a, 'b, T>(mut x: T) -> Box<dyn Anything + 'a>
| -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
...
LL | Box::new(x.next())
| ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
|

6
tests/ui/nll/ty-outlives/projection-one-region-closure.stderr
View File

@ -27,6 +27,9 @@ LL | | T: Anything<'b>,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/projection-one-region-closure.rs:45:39
|
LL | fn no_relationships_late<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -77,6 +80,9 @@ LL | | 'a: 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/projection-one-region-closure.rs:56:39
|
LL | fn no_relationships_early<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

12
tests/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr
View File

@ -26,11 +26,13 @@ LL | | T: Anything<'b, 'c>,
error[E0309]: the associated type `<T as Anything<'?5, '?6>>::AssocType` may not live long enough
--> $DIR/projection-two-region-trait-bound-closure.rs:38:39
|
LL | fn no_relationships_late<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
| -- the associated type `<T as Anything<'?5, '?6>>::AssocType` must be valid for the lifetime `'a` as defined here...
...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^ ...so that the type `<T as Anything<'?5, '?6>>::AssocType` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as Anything<'?5, '?6>>::AssocType: 'a`...
= note: ...so that the type `<T as Anything<'?5, '?6>>::AssocType` will meet its required lifetime bounds
note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:48:29
@ -60,11 +62,13 @@ LL | | 'a: 'a,
error[E0309]: the associated type `<T as Anything<'?6, '?7>>::AssocType` may not live long enough
--> $DIR/projection-two-region-trait-bound-closure.rs:48:39
|
LL | fn no_relationships_early<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
| -- the associated type `<T as Anything<'?6, '?7>>::AssocType` must be valid for the lifetime `'a` as defined here...
...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^ ...so that the type `<T as Anything<'?6, '?7>>::AssocType` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as Anything<'?6, '?7>>::AssocType: 'a`...
= note: ...so that the type `<T as Anything<'?6, '?7>>::AssocType` will meet its required lifetime bounds
note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:61:29

6
tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr
View File

@ -1,11 +1,13 @@
error[E0309]: the associated type `<T as MyTrait<'_>>::Output` may not live long enough
--> $DIR/projection-where-clause-env-wrong-bound.rs:15:5
|
LL | fn foo1<'a, 'b, T>() -> &'a ()
| -- the associated type `<T as MyTrait<'_>>::Output` must be valid for the lifetime `'a` as defined here...
...
LL | bar::<T::Output>()
| ^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^ ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as MyTrait<'_>>::Output: 'a`...
= note: ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
error: aborting due to previous error

6
tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr
View File

@ -1,11 +1,13 @@
error[E0309]: the associated type `<T as MyTrait<'_>>::Output` may not live long enough
--> $DIR/projection-where-clause-env-wrong-lifetime.rs:14:5
|
LL | fn foo1<'a, 'b, T>() -> &'a ()
| -- the associated type `<T as MyTrait<'_>>::Output` must be valid for the lifetime `'a` as defined here...
...
LL | bar::<<T as MyTrait<'a>>::Output>()
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as MyTrait<'_>>::Output: 'a`...
= note: ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
error: aborting due to previous error

3
tests/ui/nll/ty-outlives/projection-where-clause-none.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/projection-where-clause-none.rs:14:5
|
LL | fn foo<'a, T>() -> &'a ()
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | bar::<T::Output>()
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

2
tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
View File

@ -46,6 +46,8 @@ LL | fn generic_fail<'a, T>(cell: Cell<&'a ()>, value: T) {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-approximate-lower-bound.rs:29:31
|
LL | fn generic_fail<'a, T>(cell: Cell<&'a ()>, value: T) {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | twice(cell, value, |a, b| invoke(a, b));
| ^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

6
tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr
View File

@ -25,6 +25,9 @@ LL | | T: Debug,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-return-type.rs:26:27
|
LL | fn no_region<'a, T>(x: Box<T>) -> Box<dyn Debug + 'a>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | with_signature(x, |y| y)
| ^ ...so that the type `T` will meet its required lifetime bounds
|
@ -36,6 +39,9 @@ LL | T: Debug + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-return-type.rs:41:5
|
LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> Box<Debug + 'a>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|

6
tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-where-clause.stderr
View File

@ -24,6 +24,9 @@ LL | fn no_region<'a, T>(a: Cell<&'a ()>, b: T) {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:32:9
|
LL | fn no_region<'a, T>(a: Cell<&'a ()>, b: T) {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | require(&x, &y)
| ^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -84,6 +87,9 @@ LL | | T: 'b,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:65:9
|
LL | fn wrong_region<'a, 'b, T>(a: Cell<&'a ()>, b: T)
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | require(&x, &y)
| ^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

2
tests/ui/nll/ty-outlives/ty-param-fn-body.stderr
View File

@ -1,6 +1,8 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-fn-body.rs:17:5
|
LL | fn region_static<'a, T>(cell: Cell<&'a usize>, t: T) {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | outlives(cell, t)
| ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

6
tests/ui/nll/ty-outlives/ty-param-fn.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-fn.rs:9:5
|
LL | fn no_region<'a, T>(x: Box<T>) -> Box<Debug + 'a>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|
@ -12,6 +15,9 @@ LL | T: Debug + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-fn.rs:24:5
|
LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> Box<Debug + 'a>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|

35
tests/ui/nll/user-annotations/normalization-infer.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/normalization-infer.rs:11:12
|
LL | let _: <(_,) as Tr>::Ty = a;
| ^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^
| |
| the parameter type `A` must be valid for the static lifetime...
| ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,10 @@ error[E0310]: the parameter type `B` may not live long enough
--> $DIR/normalization-infer.rs:12:5
|
LL | Some::<<(_,) as Tr>::Ty>(b);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `B` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| the parameter type `B` must be valid for the static lifetime...
| ...so that the type `B` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -24,7 +30,10 @@ error[E0310]: the parameter type `C` may not live long enough
--> $DIR/normalization-infer.rs:13:11
|
LL | || -> <(_,) as Tr>::Ty { c };
| ^^^^^^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^
| |
| the parameter type `C` must be valid for the static lifetime...
| ...so that the type `C` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -35,7 +44,10 @@ error[E0310]: the parameter type `D` may not live long enough
--> $DIR/normalization-infer.rs:14:6
|
LL | |d: <(_,) as Tr>::Ty| -> D { d };
| ^ ...so that the type `D` will meet its required lifetime bounds
| ^
| |
| the parameter type `D` must be valid for the static lifetime...
| ...so that the type `D` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -46,7 +58,10 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/normalization-infer.rs:28:12
|
LL | let _: Alias<_, _> = (a, 0u8);
| ^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
| ^^^^^^^^^^^
| |
| the parameter type `A` must be valid for the static lifetime...
| ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -57,7 +72,10 @@ error[E0310]: the parameter type `B` may not live long enough
--> $DIR/normalization-infer.rs:29:5
|
LL | Some::<Alias<_, _>>((b, 0u8));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `B` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| the parameter type `B` must be valid for the static lifetime...
| ...so that the type `B` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -68,7 +86,10 @@ error[E0310]: the parameter type `C` may not live long enough
--> $DIR/normalization-infer.rs:30:11
|
LL | || -> Alias<_, _> { (c, 0u8) };
| ^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
| ^^^^^^^^^^^
| |
| the parameter type `C` must be valid for the static lifetime...
| ...so that the type `C` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

8
tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr
View File

@ -1,17 +1,11 @@
error[E0311]: the parameter type `Self` may not live long enough
|
note: the parameter type `Self` must be valid for the lifetime `'a` as defined here...
--> $DIR/object-safety-supertrait-mentions-GAT.rs:9:26
|
LL | trait SuperTrait<T>: for<'a> GatTrait<Gat<'a> = T> {
| ^^
= help: consider adding an explicit lifetime bound `Self: 'a`...
= note: ...so that the type `Self` will meet its required lifetime bounds...
note: ...that is required by this bound
--> $DIR/object-safety-supertrait-mentions-GAT.rs:6:15
|
LL | Self: 'a;
| ^^
= help: consider adding an explicit lifetime bound `Self: 'a`...
error: associated item referring to unboxed trait object for its own trait
--> $DIR/object-safety-supertrait-mentions-GAT.rs:10:20

12
tests/ui/regions/closure-in-projection-issue-97405.stderr
View File

@ -3,27 +3,33 @@ error[E0310]: the associated type `<impl Iterator as Iterator>::Item` may not li
|
LL | assert_static(opaque(async move { t; }).next());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| the associated type `<impl Iterator as Iterator>::Item` must be valid for the static lifetime...
| ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<impl Iterator as Iterator>::Item: 'static`...
= note: ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
error[E0310]: the associated type `<impl Iterator as Iterator>::Item` may not live long enough
--> $DIR/closure-in-projection-issue-97405.rs:26:5
|
LL | assert_static(opaque(move || { t; }).next());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| the associated type `<impl Iterator as Iterator>::Item` must be valid for the static lifetime...
| ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<impl Iterator as Iterator>::Item: 'static`...
= note: ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
error[E0310]: the associated type `<impl Iterator as Iterator>::Item` may not live long enough
--> $DIR/closure-in-projection-issue-97405.rs:28:5
|
LL | assert_static(opaque(opaque(async move { t; }).next()).next());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| the associated type `<impl Iterator as Iterator>::Item` must be valid for the static lifetime...
| ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<impl Iterator as Iterator>::Item: 'static`...
= note: ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
error: aborting due to 3 previous errors

16
tests/ui/regions/regions-close-associated-type-into-object.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the associated type `<T as Iter>::Item` may not live long enough
--> $DIR/regions-close-associated-type-into-object.rs:15:5
|
LL | Box::new(item)
| ^^^^^^^^^^^^^^ ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^
| |
| the associated type `<T as Iter>::Item` must be valid for the static lifetime...
| ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,10 @@ error[E0310]: the associated type `<T as Iter>::Item` may not live long enough
--> $DIR/regions-close-associated-type-into-object.rs:22:5
|
LL | Box::new(item)
| ^^^^^^^^^^^^^^ ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^
| |
| the associated type `<T as Iter>::Item` must be valid for the static lifetime...
| ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -23,6 +29,9 @@ LL | where Box<T::Item> : X, <T as Iter>::Item: 'static
error[E0309]: the associated type `<T as Iter>::Item` may not live long enough
--> $DIR/regions-close-associated-type-into-object.rs:28:5
|
LL | fn bad3<'a, T: Iter>(v: T) -> Box<dyn X + 'a>
| -- the associated type `<T as Iter>::Item` must be valid for the lifetime `'a` as defined here...
...
LL | Box::new(item)
| ^^^^^^^^^^^^^^ ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
|
@ -34,6 +43,9 @@ LL | fn bad3<'a, T: Iter>(v: T) -> Box<dyn X + 'a> where <T as Iter>::Item: 'a
error[E0309]: the associated type `<T as Iter>::Item` may not live long enough
--> $DIR/regions-close-associated-type-into-object.rs:35:5
|
LL | fn bad4<'a, T: Iter>(v: T) -> Box<dyn X + 'a>
| -- the associated type `<T as Iter>::Item` must be valid for the lifetime `'a` as defined here...
...
LL | Box::new(item)
| ^^^^^^^^^^^^^^ ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
|

20
tests/ui/regions/regions-close-object-into-object-4.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^^^ ...so that the type `U` will meet its required lifetime bounds
| ^^^^^^^^
| |
| the parameter type `U` must be valid for the static lifetime...
| ...so that the type `U` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,10 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^^^^^^^^^^^ ...so that the type `U` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^
| |
| the parameter type `U` must be valid for the static lifetime...
| ...so that the type `U` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -24,7 +30,10 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^^^^^^^^^^^ ...so that the type `U` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^
| |
| the parameter type `U` must be valid for the static lifetime...
| ...so that the type `U` will meet its required lifetime bounds
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: consider adding an explicit lifetime bound...
@ -62,7 +71,10 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:14
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^ ...so that the type `U` will meet its required lifetime bounds
| ^^^^^^
| |
| the parameter type `U` must be valid for the static lifetime...
| ...so that the type `U` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

20
tests/ui/regions/regions-close-object-into-object-5.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -24,7 +30,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: consider adding an explicit lifetime bound...
@ -45,7 +54,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:14
|
LL | Box::new(B(&*v)) as Box<dyn X>
| ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

7
tests/ui/regions/regions-close-over-type-parameter-1.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/regions-close-over-type-parameter-1.rs:11:5
|
LL | Box::new(v) as Box<dyn SomeTrait + 'static>
| ^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
| ^^^^^^^^^^^
| |
| the parameter type `A` must be valid for the static lifetime...
| ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -12,6 +15,8 @@ LL | fn make_object1<A: SomeTrait + 'static>(v: A) -> Box<dyn SomeTrait + 'stati
error[E0309]: the parameter type `A` may not live long enough
--> $DIR/regions-close-over-type-parameter-1.rs:20:5
|
LL | fn make_object3<'a, 'b, A: SomeTrait + 'a>(v: A) -> Box<dyn SomeTrait + 'b> {
| -- the parameter type `A` must be valid for the lifetime `'b` as defined here...
LL | Box::new(v) as Box<dyn SomeTrait + 'b>
| ^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|

16
tests/ui/regions/regions-close-param-into-object.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:6:5
|
LL | Box::new(v)
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:12:5
|
LL | Box::new(v)
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
@ -23,6 +29,9 @@ LL | fn p2<T: 'static>(v: Box<T>) -> Box<dyn X + 'static>
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:18:5
|
LL | fn p3<'a,T>(v: T) -> Box<dyn X + 'a>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | Box::new(v)
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -34,6 +43,9 @@ LL | where T : X + 'a
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:24:5
|
LL | fn p4<'a,T>(v: Box<T>) -> Box<dyn X + 'a>
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
...
LL | Box::new(v)
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

3
tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-implied-bounds-projection-gap-1.rs:16:5
|
LL | fn func<'x, T:Trait1<'x>>(t: &'x T::Foo)
| -- the parameter type `T` must be valid for the lifetime `'x` as defined here...
LL | {
LL | wf::<&'x T>();
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

3
tests/ui/regions/regions-infer-bound-from-trait-self.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `Self` may not live long enough
--> $DIR/regions-infer-bound-from-trait-self.rs:46:9
|
LL | trait InheritsFromNothing<'a> : Sized {
| -- the parameter type `Self` must be valid for the lifetime `'a` as defined here...
LL | fn foo(self, x: Inv<'a>) {
LL | check_bound(x, self)
| ^^^^^^^^^^^^^^^^^^^^ ...so that the type `Self` will meet its required lifetime bounds
|

4
tests/ui/regions/regions-infer-bound-from-trait.stderr
View File

@ -1,6 +1,8 @@
error[E0309]: the parameter type `A` may not live long enough
--> $DIR/regions-infer-bound-from-trait.rs:33:5
|
LL | fn bar1<'a,A>(x: Inv<'a>, a: A) {
| -- the parameter type `A` must be valid for the lifetime `'a` as defined here...
LL | check_bound(x, a)
| ^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
@ -12,6 +14,8 @@ LL | fn bar1<'a,A: 'a>(x: Inv<'a>, a: A) {
error[E0309]: the parameter type `A` may not live long enough
--> $DIR/regions-infer-bound-from-trait.rs:37:5
|
LL | fn bar2<'a,'b,A:Is<'b>>(x: Inv<'a>, y: Inv<'b>, a: A) {
| -- the parameter type `A` must be valid for the lifetime `'a` as defined here...
LL | check_bound(x, a)
| ^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|

5
tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/dont-infer-static.rs:6:10
|
LL | bar: Bar<U>
| ^^^^^^ ...so that the type `U` will meet its required lifetime bounds...
| ^^^^^^
| |
| the parameter type `U` must be valid for the static lifetime...
| ...so that the type `U` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/dont-infer-static.rs:8:15

7
tests/ui/rfcs/rfc-2093-infer-outlives/regions-enum-not-wf.stderr
View File

@ -1,6 +1,8 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-enum-not-wf.rs:17:18
|
LL | enum Ref1<'a, T> {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | Ref1Variant1(RequireOutlives<'a, T>),
| ^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -12,6 +14,9 @@ LL | enum Ref1<'a, T: 'a> {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-enum-not-wf.rs:22:25
|
LL | enum Ref2<'a, T> {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | Ref2Variant1,
LL | Ref2Variant2(isize, RequireOutlives<'a, T>),
| ^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -23,6 +28,8 @@ LL | enum Ref2<'a, T: 'a> {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-enum-not-wf.rs:35:23
|
LL | enum RefDouble<'a, 'b, T> {
| -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
LL | RefDoubleVariant1(&'a RequireOutlives<'b, T>),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

4
tests/ui/rfcs/rfc-2093-infer-outlives/regions-struct-not-wf.stderr
View File

@ -1,6 +1,8 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-struct-not-wf.rs:13:16
|
LL | impl<'a, T> Trait<'a, T> for usize {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = &'a T;
| ^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
|
@ -12,6 +14,8 @@ LL | impl<'a, T: 'a> Trait<'a, T> for usize {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-struct-not-wf.rs:21:16
|
LL | impl<'a, T> Trait<'a, T> for u32 {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = RefOk<'a, T>;
| ^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
|

6
tests/ui/suggestions/lifetimes/issue-105544.fixed
View File

@ -10,7 +10,8 @@ fn foo<'a>(d: impl Sized + 'a, p: &'a mut ()) -> impl Sized + 'a { //~ NOTE the
}
fn foo1<'b>(d: impl Sized + 'b, p: &'b mut ()) -> impl Sized + '_ {
//~^ HELP consider adding an explicit lifetime bound...
//~^ NOTE the parameter type `impl Sized` must be valid for the lifetime `'b` as defined here...
//~| HELP consider adding an explicit lifetime bound...
(d, p) //~ NOTE ...so that the type `impl Sized` will meet its required lifetime bounds
//~^ ERROR the parameter type `impl Sized` may not live long enough
}
@ -30,7 +31,8 @@ fn bar<'a, T : Sized + 'a>(d: T, p: &'a mut ()) -> impl Sized + 'a { //~ NOTE t
}
fn bar1<'b, T : Sized + 'b>(d: T, p: &'b mut ()) -> impl Sized + '_ {
//~^ HELP consider adding an explicit lifetime bound...
//~^ NOTE the parameter type `T` must be valid for the lifetime `'b` as defined here...
//~| HELP consider adding an explicit lifetime bound...
(d, p) //~ NOTE ...so that the type `T` will meet its required lifetime bounds
//~^ ERROR the parameter type `T` may not live long enough
}

6
tests/ui/suggestions/lifetimes/issue-105544.rs
View File

@ -10,7 +10,8 @@ fn foo(d: impl Sized, p: &mut ()) -> impl Sized + '_ { //~ NOTE the parameter ty
}
fn foo1<'b>(d: impl Sized, p: &'b mut ()) -> impl Sized + '_ {
//~^ HELP consider adding an explicit lifetime bound...
//~^ NOTE the parameter type `impl Sized` must be valid for the lifetime `'b` as defined here...
//~| HELP consider adding an explicit lifetime bound...
(d, p) //~ NOTE ...so that the type `impl Sized` will meet its required lifetime bounds
//~^ ERROR the parameter type `impl Sized` may not live long enough
}
@ -30,7 +31,8 @@ fn bar<T : Sized>(d: T, p: & mut ()) -> impl Sized + '_ { //~ NOTE the parameter
}
fn bar1<'b, T : Sized>(d: T, p: &'b mut ()) -> impl Sized + '_ {
//~^ HELP consider adding an explicit lifetime bound...
//~^ NOTE the parameter type `T` must be valid for the lifetime `'b` as defined here...
//~| HELP consider adding an explicit lifetime bound...
(d, p) //~ NOTE ...so that the type `T` will meet its required lifetime bounds
//~^ ERROR the parameter type `T` may not live long enough
}

76
tests/ui/suggestions/lifetimes/issue-105544.stderr
View File

@ -1,27 +1,23 @@
error[E0311]: the parameter type `impl Sized` may not live long enough
--> $DIR/issue-105544.rs:7:5
|
LL | (d, p)
| ^^^^^^
|
note: the parameter type `impl Sized` must be valid for the anonymous lifetime defined here...
--> $DIR/issue-105544.rs:5:26
|
LL | fn foo(d: impl Sized, p: &mut ()) -> impl Sized + '_ {
| ^^^^^^^
note: ...so that the type `impl Sized` will meet its required lifetime bounds
--> $DIR/issue-105544.rs:7:5
|
| ------- the parameter type `impl Sized` must be valid for the anonymous lifetime defined here...
LL |
LL | (d, p)
| ^^^^^^
| ^^^^^^ ...so that the type `impl Sized` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | fn foo<'a>(d: impl Sized + 'a, p: &'a mut ()) -> impl Sized + 'a {
| ++++ ++++ ++ ~~
error[E0309]: the parameter type `impl Sized` may not live long enough
--> $DIR/issue-105544.rs:14:5
--> $DIR/issue-105544.rs:15:5
|
LL | fn foo1<'b>(d: impl Sized, p: &'b mut ()) -> impl Sized + '_ {
| -- the parameter type `impl Sized` must be valid for the lifetime `'b` as defined here...
...
LL | (d, p)
| ^^^^^^ ...so that the type `impl Sized` will meet its required lifetime bounds
|
@ -31,50 +27,39 @@ LL | fn foo1<'b>(d: impl Sized + 'b, p: &'b mut ()) -> impl Sized + '_ {
| ++++
error[E0311]: the parameter type `impl Sized + 'a` may not live long enough
--> $DIR/issue-105544.rs:20:5
|
LL | (d, p)
| ^^^^^^
|
note: the parameter type `impl Sized + 'a` must be valid for the anonymous lifetime defined here...
--> $DIR/issue-105544.rs:18:36
--> $DIR/issue-105544.rs:21:5
|
LL | fn foo2<'a>(d: impl Sized + 'a, p: &mut ()) -> impl Sized + '_ {
| ^^^^^^^
note: ...so that the type `impl Sized + 'a` will meet its required lifetime bounds
--> $DIR/issue-105544.rs:20:5
|
| ------- the parameter type `impl Sized + 'a` must be valid for the anonymous lifetime defined here...
LL |
LL | (d, p)
| ^^^^^^
| ^^^^^^ ...so that the type `impl Sized + 'a` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | fn foo2<'b, 'a>(d: impl Sized + 'a + 'b, p: &'b mut ()) -> impl Sized + 'b {
| +++ ++++ ++ ~~
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/issue-105544.rs:27:5
|
LL | (d, p)
| ^^^^^^
|
note: the parameter type `T` must be valid for the anonymous lifetime defined here...
--> $DIR/issue-105544.rs:25:28
--> $DIR/issue-105544.rs:28:5
|
LL | fn bar<T : Sized>(d: T, p: & mut ()) -> impl Sized + '_ {
| ^^^^^^^^
note: ...so that the type `T` will meet its required lifetime bounds
--> $DIR/issue-105544.rs:27:5
|
| -------- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL |
LL | (d, p)
| ^^^^^^
| ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | fn bar<'a, T : Sized + 'a>(d: T, p: &'a mut ()) -> impl Sized + 'a {
| +++ ++++ ++ ~~
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/issue-105544.rs:34:5
--> $DIR/issue-105544.rs:36:5
|
LL | fn bar1<'b, T : Sized>(d: T, p: &'b mut ()) -> impl Sized + '_ {
| -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
...
LL | (d, p)
| ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -84,21 +69,14 @@ LL | fn bar1<'b, T : Sized + 'b>(d: T, p: &'b mut ()) -> impl Sized + '_ {
| ++++
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/issue-105544.rs:40:5
|
LL | (d, p)
| ^^^^^^
|
note: the parameter type `T` must be valid for the anonymous lifetime defined here...
--> $DIR/issue-105544.rs:38:38
--> $DIR/issue-105544.rs:42:5
|
LL | fn bar2<'a, T : Sized + 'a>(d: T, p: &mut ()) -> impl Sized + '_ {
| ^^^^^^^
note: ...so that the type `T` will meet its required lifetime bounds
--> $DIR/issue-105544.rs:40:5
|
| ------- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL |
LL | (d, p)
| ^^^^^^
| ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | fn bar2<'b, 'a, T : Sized + 'a + 'b>(d: T, p: &'b mut ()) -> impl Sized + 'b {

17
tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr
View File

@ -1,25 +1,14 @@
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/missing-lifetimes-in-signature-2.rs:23:5
|
LL | fn func<T: Test>(_dummy: &Foo, foo: &Foo, t: T) {
| --- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL | / foo.bar(move |_| {
LL | |
LL | | t.test();
LL | | });
| |______^
| |______^ ...so that the type `T` will meet its required lifetime bounds
|
note: the parameter type `T` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature-2.rs:22:38
|
LL | fn func<T: Test>(_dummy: &Foo, foo: &Foo, t: T) {
| ^^^
note: ...so that the type `T` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature-2.rs:23:5
|
LL | / foo.bar(move |_| {
LL | |
LL | | t.test();
LL | | });
| |______^
help: consider adding an explicit lifetime bound...
|
LL | fn func<'a, T: Test + 'a>(_dummy: &Foo, foo: &Foo<'a>, t: T) {

75
tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
View File

@ -28,25 +28,15 @@ LL | fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:30:5
|
LL | fn bar<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^
| |_____^ ...so that the type `G` will meet its required lifetime bounds
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:26:26
|
LL | fn bar<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^
note: ...so that the type `G` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:30:5
|
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^
help: consider adding an explicit lifetime bound...
|
LL ~ fn bar<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
@ -57,25 +47,15 @@ LL ~ G: Get<T> + 'a,
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:52:5
|
LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^
| |_____^ ...so that the type `G` will meet its required lifetime bounds
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:48:34
|
LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^
note: ...so that the type `G` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:52:5
|
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^
help: consider adding an explicit lifetime bound...
|
LL | fn qux<'b, 'a, G: 'a + 'b, T>(g: G, dest: &'b mut T) -> impl FnOnce() + 'b
@ -84,25 +64,14 @@ LL | fn qux<'b, 'a, G: 'a + 'b, T>(g: G, dest: &'b mut T) -> impl FnOnce() + 'b
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:61:9
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_________^
| |_________^ ...so that the type `G` will meet its required lifetime bounds
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:60:47
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| ^^^^^^
note: ...so that the type `G` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:61:9
|
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_________^
help: consider adding an explicit lifetime bound...
|
LL | fn qux<'c, 'b, G: Get<T> + 'b + 'c, T>(g: G, dest: &'c mut T) -> impl FnOnce() + 'c {
@ -111,27 +80,16 @@ LL | fn qux<'c, 'b, G: Get<T> + 'b + 'c, T>(g: G, dest: &'c mut T) -> impl F
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:73:5
|
LL | fn bat<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
| ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
...
LL | / move || {
LL | |
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^
| |_____^ ...so that the type `G` will meet its required lifetime bounds
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:69:34
|
LL | fn bat<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
| ^^^^^^
note: ...so that the type `G` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:73:5
|
LL | / move || {
LL | |
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^
help: consider adding an explicit lifetime bound...
|
LL | fn bat<'b, 'a, G: 'a + 'b, T>(g: G, dest: &'b mut T) -> impl FnOnce() + 'b + 'a
@ -153,6 +111,9 @@ LL | | }
error[E0309]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:85:5
|
LL | fn bak<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
| -- the parameter type `G` must be valid for the lifetime `'a` as defined here...
...
LL | / move || {
LL | |
LL | | *dest = g.get();

13
tests/ui/suggestions/lifetimes/type-param-bound-scope.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the parameter type `Self` may not live long enough
--> $DIR/type-param-bound-scope.rs:11:9
|
LL | trait Trait1<'a>: Sized {
| -- the parameter type `Self` must be valid for the lifetime `'a` as defined here...
LL | fn foo(self, lt: Inv<'a>) {
LL | check_bound(self, lt)
| ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `Self` will meet its required lifetime bounds
|
@ -12,6 +15,8 @@ LL | trait Trait1<'a>: Sized where Self: 'a {
error[E0309]: the parameter type `Self` may not live long enough
--> $DIR/type-param-bound-scope.rs:18:9
|
LL | fn foo<'a>(self, lt: Inv<'a>) {
| -- the parameter type `Self` must be valid for the lifetime `'a` as defined here...
LL | check_bound(self, lt)
| ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `Self` will meet its required lifetime bounds
|
@ -23,6 +28,8 @@ LL | fn foo<'a>(self, lt: Inv<'a>) where Self: 'a {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/type-param-bound-scope.rs:25:9
|
LL | fn foo<'a>(arg: T, lt: Inv<'a>) {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | check_bound(arg, lt)
| ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -34,6 +41,9 @@ LL | fn foo<'a>(arg: T, lt: Inv<'a>) where T: 'a {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/type-param-bound-scope.rs:32:9
|
LL | trait Trait4<'a> {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | fn foo<T>(arg: T, lt: Inv<'a>) {
LL | check_bound(arg, lt)
| ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
@ -45,6 +55,9 @@ LL | fn foo<T: 'a>(arg: T, lt: Inv<'a>) {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/type-param-bound-scope.rs:42:9
|
LL | impl<'a, T> Trait5<'a> for T {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | fn foo(self, lt: Inv<'a>) {
LL | check_bound(self, lt);
| ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|

59
tests/ui/suggestions/lifetimes/type-param-missing-lifetime.stderr
View File

@ -1,19 +1,12 @@
error[E0311]: the parameter type `A` may not live long enough
--> $DIR/type-param-missing-lifetime.rs:16:9
|
LL | check_bound(arg, self.0 .0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: the parameter type `A` must be valid for the anonymous lifetime as defined here...
--> $DIR/type-param-missing-lifetime.rs:14:21
|
LL | impl<X> MyTy<Elided<'_, X>> {
| ^^
note: ...so that the type `A` will meet its required lifetime bounds
--> $DIR/type-param-missing-lifetime.rs:16:9
|
| -- the parameter type `A` must be valid for the anonymous lifetime as defined here...
LL | async fn foo<A>(self, arg: A, _: &str) -> &str {
LL | check_bound(arg, self.0 .0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL ~ impl<'a, X> MyTy<Elided<'a, X>> {
@ -23,19 +16,12 @@ LL ~ async fn foo<A: 'a>(self, arg: A, _: &str) -> &str {
error[E0311]: the parameter type `A` may not live long enough
--> $DIR/type-param-missing-lifetime.rs:33:9
|
LL | check_bound(arg, lt);
| ^^^^^^^^^^^^^^^^^^^^
|
note: the parameter type `A` must be valid for the anonymous lifetime defined here...
--> $DIR/type-param-missing-lifetime.rs:27:13
|
LL | lt: Inv<'_>,
| ^^^^^^^
note: ...so that the type `A` will meet its required lifetime bounds
--> $DIR/type-param-missing-lifetime.rs:33:9
|
| ------- the parameter type `A` must be valid for the anonymous lifetime defined here...
...
LL | check_bound(arg, lt);
| ^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL ~ async fn foo2<'b>(
@ -51,19 +37,11 @@ LL ~ ) where A: 'b {
error[E0311]: the parameter type `A` may not live long enough
--> $DIR/type-param-missing-lifetime.rs:40:9
|
LL | check_bound(arg, lt);
| ^^^^^^^^^^^^^^^^^^^^
|
note: the parameter type `A` must be valid for the anonymous lifetime defined here...
--> $DIR/type-param-missing-lifetime.rs:39:51
|
LL | async fn bar2<'b>(_dummy: &'a u8, arg: A, lt: Inv<'_>) {
| ^^^^^^^
note: ...so that the type `A` will meet its required lifetime bounds
--> $DIR/type-param-missing-lifetime.rs:40:9
|
| ------- the parameter type `A` must be valid for the anonymous lifetime defined here...
LL | check_bound(arg, lt);
| ^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | async fn bar2<'c, 'b>(_dummy: &'a u8, arg: A, lt: Inv<'c>) where A: 'c {
@ -72,19 +50,12 @@ LL | async fn bar2<'c, 'b>(_dummy: &'a u8, arg: A, lt: Inv<'c>) where A: 'c
error[E0311]: the parameter type `A` may not live long enough
--> $DIR/type-param-missing-lifetime.rs:47:9
|
LL | check_bound(self.0 .1, self.0 .0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: the parameter type `A` must be valid for the anonymous lifetime as defined here...
--> $DIR/type-param-missing-lifetime.rs:45:21
|
LL | impl<A> MyTy<Elided<'_, A>> {
| ^^
note: ...so that the type `A` will meet its required lifetime bounds
--> $DIR/type-param-missing-lifetime.rs:47:9
|
| -- the parameter type `A` must be valid for the anonymous lifetime as defined here...
LL | async fn foo3(self) {
LL | check_bound(self.0 .1, self.0 .0);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|
LL | impl<'a, A: 'a> MyTy<Elided<'a, A>> {

1
tests/ui/suggestions/suggest-impl-trait-lifetime.fixed
View File

@ -6,6 +6,7 @@ fn foo(d: impl Debug + 'static) {
//~^ HELP consider adding an explicit lifetime bound...
bar(d);
//~^ ERROR the parameter type `impl Debug` may not live long enough
//~| NOTE the parameter type `impl Debug` must be valid for the static lifetime...
//~| NOTE ...so that the type `impl Debug` will meet its required lifetime bounds
}

1
tests/ui/suggestions/suggest-impl-trait-lifetime.rs
View File

@ -6,6 +6,7 @@ fn foo(d: impl Debug) {
//~^ HELP consider adding an explicit lifetime bound...
bar(d);
//~^ ERROR the parameter type `impl Debug` may not live long enough
//~| NOTE the parameter type `impl Debug` must be valid for the static lifetime...
//~| NOTE ...so that the type `impl Debug` will meet its required lifetime bounds
}

5
tests/ui/suggestions/suggest-impl-trait-lifetime.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `impl Debug` may not live long enough
--> $DIR/suggest-impl-trait-lifetime.rs:7:5
|
LL | bar(d);
| ^^^^^^ ...so that the type `impl Debug` will meet its required lifetime bounds
| ^^^^^^
| |
| the parameter type `impl Debug` must be valid for the static lifetime...
| ...so that the type `impl Debug` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

5
tests/ui/type-alias-impl-trait/closure_wf_outlives.stderr
View File

@ -46,7 +46,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/closure_wf_outlives.rs:54:22
|
LL | type Opaque<T> = impl Sized;
| ^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
| ^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/closure_wf_outlives.rs:59:12

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

@ -17,7 +17,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/generic_type_does_not_live_long_enough.rs:13:9
|
LL | t
| ^ ...so that the type `T` will meet its required lifetime bounds
| ^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

5
tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.stderr
View File

@ -22,7 +22,10 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/implied_lifetime_wf_check3.rs:29:41
|
LL | fn test<A>() where Ty<A>: 'static { assert_static::<A>() }
| ^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^^
| |
| the parameter type `A` must be valid for the static lifetime...
| ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

5
tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/implied_lifetime_wf_check4_static.rs:4:18
|
LL | type Ty<A> = impl Sized + 'static;
| ^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
| ^^^^^^^^^^^^^^^^^^^^
| |
| the parameter type `A` must be valid for the static lifetime...
| ...so that the type `A` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

4
tests/ui/type-alias-impl-trait/wf-in-associated-type.fail.stderr
View File

@ -1,6 +1,8 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-in-associated-type.rs:36:23
|
LL | impl<'a, T> Trait<'a, T> for () {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Opaque = impl Sized + 'a;
| ^^^^^^^^^^^^^^^ ...so that the type `&'a T` will meet its required lifetime bounds
|
@ -12,6 +14,8 @@ LL | impl<'a, T: 'a> Trait<'a, T> for () {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-in-associated-type.rs:36:23
|
LL | impl<'a, T> Trait<'a, T> for () {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Opaque = impl Sized + 'a;
| ^^^^^^^^^^^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
|

5
tests/ui/type-alias-impl-trait/wf-nested.fail.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-nested.rs:55:27
|
LL | type InnerOpaque<T> = impl Sized;
| ^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
| ^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/wf-nested.rs:12:20

5
tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-nested.rs:46:17
|
LL | let _ = outer.get();
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
| ^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the type `T` will meet its required lifetime bounds
|
help: consider adding an explicit lifetime bound...
|

2
tests/ui/wf/wf-impl-associated-type-region.stderr
View File

@ -1,6 +1,8 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-impl-associated-type-region.rs:10:16
|
LL | impl<'a, T> Foo<'a> for T {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Bar = &'a T;
| ^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
|

10
tests/ui/wf/wf-in-fn-type-static.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-in-fn-type-static.rs:13:8
|
LL | x: fn() -> &'static T
| ^^^^^^^^^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
| ^^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the reference type `&'static T` does not outlive the data it points at
|
help: consider adding an explicit lifetime bound...
|
@ -13,7 +16,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-in-fn-type-static.rs:18:8
|
LL | x: fn(&'static T)
| ^^^^^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
| ^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the reference type `&'static T` does not outlive the data it points at
|
help: consider adding an explicit lifetime bound...
|

5
tests/ui/wf/wf-in-obj-type-static.stderr
View File

@ -2,7 +2,10 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-in-obj-type-static.rs:14:8
|
LL | x: dyn Object<&'static T>
| ^^^^^^^^^^^^^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
| ^^^^^^^^^^^^^^^^^^^^^^
| |
| the parameter type `T` must be valid for the static lifetime...
| ...so that the reference type `&'static T` does not outlive the data it points at
|
help: consider adding an explicit lifetime bound...
|

4
tests/ui/wf/wf-outlives-ty-in-fn-or-trait.stderr
View File

@ -1,6 +1,8 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-outlives-ty-in-fn-or-trait.rs:9:16
|
LL | impl<'a, T> Trait<'a, T> for usize {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = &'a fn(T);
| ^^^^^^^^^ ...so that the reference type `&'a fn(T)` does not outlive the data it points at
|
@ -12,6 +14,8 @@ LL | impl<'a, T: 'a> Trait<'a, T> for usize {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-outlives-ty-in-fn-or-trait.rs:19:16
|
LL | impl<'a, T> Trait<'a, T> for u32 {
| -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = &'a dyn Baz<T>;
| ^^^^^^^^^^^^^^ ...so that the reference type `&'a (dyn Baz<T> + 'a)` does not outlive the data it points at
|

3
tests/ui/wf/wf-trait-associated-type-region.stderr
View File

@ -1,6 +1,9 @@
error[E0309]: the associated type `<Self as SomeTrait<'a>>::Type1` may not live long enough
--> $DIR/wf-trait-associated-type-region.rs:9:18
|
LL | trait SomeTrait<'a> {
| -- the associated type `<Self as SomeTrait<'a>>::Type1` must be valid for the lifetime `'a` as defined here...
LL | type Type1;
LL | type Type2 = &'a Self::Type1;
| ^^^^^^^^^^^^^^^ ...so that the reference type `&'a <Self as SomeTrait<'a>>::Type1` does not outlive the data it points at
|