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

Bless tests.

Browse Source
This commit is contained in:
Camille GILLOT 2022-03-06 15:44:48 +01:00
parent fc9f25531a
commit ca57bada05
24 changed files with 527 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/test/ui/generic-associated-types/gat-in-trait-path-undeclared-lifetime.stderr
View File

@ -2,9 +2,17 @@ error[E0261]: use of undeclared lifetime name `'x`
--> $DIR/gat-in-trait-path-undeclared-lifetime.rs:8:35
|
LL | fn _f(arg : Box<dyn for<'a> X<Y<'x> = &'a [u32]>>) {}
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'x` here: `<'x>`
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'x` lifetime
|
LL | fn _f(arg : Box<dyn for<'x, 'a> X<Y<'x> = &'a [u32]>>) {}
| +++
help: consider introducing lifetime `'x` here
|
LL | fn _f<'x>(arg : Box<dyn for<'a> X<Y<'x> = &'a [u32]>>) {}
| ++++
error[E0582]: binding for associated type `Y` references lifetime `'a`, which does not appear in the trait input types
--> $DIR/gat-in-trait-path-undeclared-lifetime.rs:8:33

19
src/test/ui/generic-associated-types/generic_associated_type_undeclared_lifetimes.stderr
View File

@ -4,14 +4,19 @@ error[E0261]: use of undeclared lifetime name `'b`
LL | + Deref<Target = Self::Item<'b>>;
| ^^ undeclared lifetime
|
help: consider introducing lifetime `'b` here
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'b` lifetime
|
LL | trait Iterable<'b> {
| ++++
LL | + for<'b> Deref<Target = Self::Item<'b>>;
| +++++++
help: consider introducing lifetime `'b` here
|
LL | type Iter<'b, 'a>: Iterator<Item = Self::Item<'a>>
| +++
help: consider introducing lifetime `'b` here
|
LL | trait Iterable<'b> {
| ++++
error[E0261]: use of undeclared lifetime name `'undeclared`
--> $DIR/generic_associated_type_undeclared_lifetimes.rs:11:41
@ -21,12 +26,12 @@ LL | fn iter<'a>(&'a self) -> Self::Iter<'undeclared>;
|
help: consider introducing lifetime `'undeclared` here
|
LL | trait Iterable<'undeclared> {
| +++++++++++++
help: consider introducing lifetime `'undeclared` here
|
LL | fn iter<'undeclared, 'a>(&'a self) -> Self::Iter<'undeclared>;
| ++++++++++++
help: consider introducing lifetime `'undeclared` here
|
LL | trait Iterable<'undeclared> {
| +++++++++++++
error: aborting due to 2 previous errors

8
src/test/ui/generic-associated-types/issue-67510.rs
View File

@ -4,9 +4,9 @@ trait X {
type Y<'a>;
}
fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {}
//~^ ERROR: use of undeclared lifetime name `'a`
//~| ERROR: use of undeclared lifetime name `'a`
fn f(x: Box<dyn X<Y<'a> = &'a ()>>) {}
//~^ ERROR: use of undeclared lifetime name `'a`
//~| ERROR: use of undeclared lifetime name `'a`
//~| ERROR: the trait `X` cannot be made into an object [E0038]
fn main() {}

53
src/test/ui/generic-associated-types/issue-67510.stderr
View File

@ -1,19 +1,50 @@
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/issue-67510.rs:7:21
|
LL | fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {}
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
LL | fn f(x: Box<dyn X<Y<'a> = &'a ()>>) {}
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'a` lifetime
|
LL | fn f(x: Box<dyn for<'a> X<Y<'a> = &'a ()>>) {}
| +++++++
help: consider introducing lifetime `'a` here
|
LL | fn f<'a>(x: Box<dyn X<Y<'a> = &'a ()>>) {}
| ++++
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/issue-67510.rs:7:26
--> $DIR/issue-67510.rs:7:28
|
LL | fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {}
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
LL | fn f(x: Box<dyn X<Y<'a> = &'a ()>>) {}
| ^^ undeclared lifetime
|
help: consider making the bound lifetime-generic with a new `'a` lifetime
|
LL | fn f(x: Box<dyn for<'a> X<Y<'a> = &'a ()>>) {}
| +++++++
help: consider introducing lifetime `'a` here
|
LL | fn f<'a>(x: Box<dyn X<Y<'a> = &'a ()>>) {}
| ++++
error: aborting due to 2 previous errors
error[E0038]: the trait `X` cannot be made into an object
--> $DIR/issue-67510.rs:7:13
|
LL | fn f(x: Box<dyn X<Y<'a> = &'a ()>>) {}
| ^^^^^^^^^^^^^^^^^^^^^ `X` cannot be made into an object
|
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
--> $DIR/issue-67510.rs:4:10
|
LL | trait X {
| - this trait cannot be made into an object...
LL | type Y<'a>;
| ^ ...because it contains the generic associated type `Y`
= help: consider moving `Y` to another trait
For more information about this error, try `rustc --explain E0261`.
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0038, E0261.
For more information about an error, try `rustc --explain E0038`.

13
src/test/ui/generic-associated-types/issue-70304.rs
View File

@ -12,13 +12,10 @@ impl Document for DocumentImpl {
type Cursor<'a> = DocCursorImpl<'a>;
fn cursor(&self) -> Self::Cursor<'_> {
DocCursorImpl {
document: &self,
}
DocCursorImpl { document: &self }
}
}
trait DocCursor<'a> {}
struct DocCursorImpl<'a> {
@ -35,7 +32,6 @@ struct Lexer<'d, Cursor>
_phantom: std::marker::PhantomData<&'d ()>,
}
impl<'d, Cursor> Lexer<'d, Cursor>
where
Cursor: DocCursor<'d>,
@ -44,15 +40,12 @@ pub fn from<Doc>(document: &'d Doc) -> Lexer<'d, Cursor>
where
Doc: Document<Cursor<'d> = Cursor>,
{
Lexer {
cursor: document.cursor(),
_phantom: std::marker::PhantomData,
}
Lexer { cursor: document.cursor(), _phantom: std::marker::PhantomData }
}
}
fn create_doc() -> impl Document<Cursor<'_> = DocCursorImpl<'_>> {
//~^ ERROR: missing lifetime specifier
//~^ ERROR: missing lifetime specifier
DocumentImpl {}
}

2
src/test/ui/generic-associated-types/issue-70304.stderr
View File

@ -1,5 +1,5 @@
error[E0106]: missing lifetime specifier
--> $DIR/issue-70304.rs:54:41
--> $DIR/issue-70304.rs:47:41
|
LL | fn create_doc() -> impl Document<Cursor<'_> = DocCursorImpl<'_>> {
| ^^ expected named lifetime parameter

21
src/test/ui/generics/generic-extern-lifetime.stderr
View File

@ -2,7 +2,9 @@ error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/generic-extern-lifetime.rs:6:26
|
LL | pub fn life2<'b>(x: &'a i32, y: &'b i32);
| ^^ undeclared lifetime
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `'a,`
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/generic-extern-lifetime.rs:8:37
@ -13,8 +15,12 @@ LL | pub fn life4<'b>(x: for<'c> fn(&'a i32));
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the type lifetime-generic with a new `'a` lifetime
|
LL | pub fn life4<'b>(x: for<'c, 'a> fn(&'a i32));
| ++++
LL | pub fn life4<'b>(x: for<'a, 'c> fn(&'a i32));
| +++
help: consider introducing lifetime `'a` here
|
LL | pub fn life4<'a, 'b>(x: for<'c> fn(&'a i32));
| +++
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/generic-extern-lifetime.rs:11:39
@ -22,11 +28,14 @@ error[E0261]: use of undeclared lifetime name `'a`
LL | pub fn life7<'b>() -> for<'c> fn(&'a i32);
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the type lifetime-generic with a new `'a` lifetime
|
LL | pub fn life7<'b>() -> for<'c, 'a> fn(&'a i32);
| ++++
LL | pub fn life7<'b>() -> for<'a, 'c> fn(&'a i32);
| +++
help: consider introducing lifetime `'a` here
|
LL | pub fn life7<'a, 'b>() -> for<'c> fn(&'a i32);
| +++
error: aborting due to 3 previous errors

7
src/test/ui/impl-header-lifetime-elision/trait-elided.rs
View File

@ -1,9 +1,8 @@
#![allow(warnings)]
trait MyTrait<'a> { }
trait MyTrait<'a> {}
impl MyTrait for u32 {
//~^ ERROR implicit elided lifetime not allowed here
}
impl MyTrait for u32 {}
//~^ ERROR implicit elided lifetime not allowed here
fn main() {}

2
src/test/ui/impl-header-lifetime-elision/trait-elided.stderr
View File

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

18
src/test/ui/issues/issue-10412.rs
View File

@ -1,16 +1,20 @@
trait Serializable<'self, T> { //~ ERROR lifetimes cannot use keyword names
fn serialize(val : &'self T) -> Vec<u8>; //~ ERROR lifetimes cannot use keyword names
fn deserialize(repr : &[u8]) -> &'self T; //~ ERROR lifetimes cannot use keyword names
trait Serializable<'self, T> {
//~^ ERROR lifetimes cannot use keyword names
fn serialize(val: &'self T) -> Vec<u8>; //~ ERROR lifetimes cannot use keyword names
fn deserialize(repr: &[u8]) -> &'self T; //~ ERROR lifetimes cannot use keyword names
}
impl<'self> Serializable<str> for &'self str { //~ ERROR lifetimes cannot use keyword names
impl<'self> Serializable<str> for &'self str {
//~^ ERROR lifetimes cannot use keyword names
//~| ERROR lifetimes cannot use keyword names
//~| ERROR implicit elided lifetime not allowed here
//~| ERROR the size for values of type `str` cannot be known at compilation time
fn serialize(val : &'self str) -> Vec<u8> { //~ ERROR lifetimes cannot use keyword names
//~| ERROR the size for values of type `str` cannot be known at compilation time [E0277]
fn serialize(val: &'self str) -> Vec<u8> {
//~^ ERROR lifetimes cannot use keyword names
vec![1]
}
fn deserialize(repr: &[u8]) -> &'self str { //~ ERROR lifetimes cannot use keyword names
fn deserialize(repr: &[u8]) -> &'self str {
//~^ ERROR lifetimes cannot use keyword names
"hi"
}
}

28
src/test/ui/issues/issue-10412.stderr
View File

@ -5,43 +5,43 @@ LL | trait Serializable<'self, T> {
| ^^^^^
error: lifetimes cannot use keyword names
--> $DIR/issue-10412.rs:2:25
--> $DIR/issue-10412.rs:3:24
|
LL | fn serialize(val : &'self T) -> Vec<u8>;
| ^^^^^
LL | fn serialize(val: &'self T) -> Vec<u8>;
| ^^^^^
error: lifetimes cannot use keyword names
--> $DIR/issue-10412.rs:3:38
--> $DIR/issue-10412.rs:4:37
|
LL | fn deserialize(repr : &[u8]) -> &'self T;
| ^^^^^
LL | fn deserialize(repr: &[u8]) -> &'self T;
| ^^^^^
error: lifetimes cannot use keyword names
--> $DIR/issue-10412.rs:6:6
--> $DIR/issue-10412.rs:7:6
|
LL | impl<'self> Serializable<str> for &'self str {
| ^^^^^
error: lifetimes cannot use keyword names
--> $DIR/issue-10412.rs:6:36
--> $DIR/issue-10412.rs:7:36
|
LL | impl<'self> Serializable<str> for &'self str {
| ^^^^^
error: lifetimes cannot use keyword names
--> $DIR/issue-10412.rs:10:25
--> $DIR/issue-10412.rs:12:24
|
LL | fn serialize(val : &'self str) -> Vec<u8> {
| ^^^^^
LL | fn serialize(val: &'self str) -> Vec<u8> {
| ^^^^^
error: lifetimes cannot use keyword names
--> $DIR/issue-10412.rs:13:37
--> $DIR/issue-10412.rs:16:37
|
LL | fn deserialize(repr: &[u8]) -> &'self str {
| ^^^^^
error[E0726]: implicit elided lifetime not allowed here
--> $DIR/issue-10412.rs:6:13
--> $DIR/issue-10412.rs:7:13
|
LL | impl<'self> Serializable<str> for &'self str {
| ^^^^^^^^^^^^^^^^^ help: indicate the anonymous lifetime: `Serializable<'_, str>`
@ -49,7 +49,7 @@ LL | impl<'self> Serializable<str> for &'self str {
= note: assuming a `'static` lifetime...
error[E0277]: the size for values of type `str` cannot be known at compilation time
--> $DIR/issue-10412.rs:6:13
--> $DIR/issue-10412.rs:7:13
|
LL | impl<'self> Serializable<str> for &'self str {
| ^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time

10
src/test/ui/lifetimes/undeclared-lifetime-used-in-debug-macro-issue-70152.stderr
View File

@ -9,6 +9,8 @@ LL | a: &'b str,
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/undeclared-lifetime-used-in-debug-macro-issue-70152.rs:3:9
|
LL | #[derive(Eq, PartialEq)]
| -- lifetime `'b` is missing in item created through this procedural macro
LL | struct Test {
| - help: consider introducing lifetime `'b` here: `<'b>`
LL | a: &'b str,
@ -22,12 +24,12 @@ LL | fn foo(&'b self) {}
|
help: consider introducing lifetime `'b` here
|
LL | impl<'b> T for Test {
| ++++
help: consider introducing lifetime `'b` here
|
LL | fn foo<'b>(&'b self) {}
| ++++
help: consider introducing lifetime `'b` here
|
LL | impl<'b> T for Test {
| ++++
error: aborting due to 3 previous errors

5
src/test/ui/methods/method-call-lifetime-args-unresolved.rs
View File

@ -1,3 +1,6 @@
fn main() {
0.clone::<'a>(); //~ ERROR use of undeclared lifetime name `'a`
0.clone::<'a>();
//~^ ERROR use of undeclared lifetime name `'a`
//~| WARN cannot specify lifetime arguments explicitly if late bound
//~| WARN this was previously accepted by the compiler
}

17
src/test/ui/methods/method-call-lifetime-args-unresolved.stderr
View File

@ -6,6 +6,21 @@ LL | fn main() {
LL | 0.clone::<'a>();
| ^^ undeclared lifetime
error: aborting due to previous error
warning: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
--> $DIR/method-call-lifetime-args-unresolved.rs:2:15
|
LL | 0.clone::<'a>();
| ^^
|
::: $SRC_DIR/core/src/clone.rs:LL:COL
|
LL | fn clone(&self) -> Self;
| - the late bound lifetime parameter is introduced here
|
= note: `#[warn(late_bound_lifetime_arguments)]` on by default
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #42868 <https://github.com/rust-lang/rust/issues/42868>
error: aborting due to previous error; 1 warning emitted
For more information about this error, try `rustc --explain E0261`.

5
src/test/ui/regions/regions-name-static.rs
View File

@ -1,5 +1,6 @@
struct Foo<'static> { //~ ERROR invalid lifetime parameter name: `'static`
x: &'static isize
struct Foo<'static> {
//~^ ERROR invalid lifetime parameter name: `'static`
x: &'static isize,
}
fn main() {}

8
src/test/ui/regions/regions-name-undeclared.rs
View File

@ -23,14 +23,14 @@ fn bar<'a>(x: &'a isize) {
let y: &'a isize = x;
// &'a is not visible to *items*:
type X = Option<&'a isize>; //~ ERROR undeclared lifetime
type X = Option<&'a isize>; //~ ERROR can't use generic parameters from outer item
enum E {
E1(&'a isize) //~ ERROR undeclared lifetime
E1(&'a isize) //~ ERROR can't use generic parameters from outer item
}
struct S {
f: &'a isize //~ ERROR undeclared lifetime
f: &'a isize //~ ERROR can't use generic parameters from outer item
}
fn f(a: &'a isize) { } //~ ERROR undeclared lifetime
fn f(a: &'a isize) { } //~ ERROR can't use generic parameters from outer item
// &'a CAN be declared on functions and used then:
fn g<'a>(a: &'a isize) { } // OK

104
src/test/ui/regions/regions-name-undeclared.stderr
View File

@ -1,19 +1,3 @@
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:28:13
|
LL | enum E {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | E1(&'a isize)
| ^^ undeclared lifetime
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:31:13
|
LL | struct S {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | f: &'a isize
| ^^ undeclared lifetime
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/regions-name-undeclared.rs:16:24
|
@ -22,12 +6,12 @@ LL | fn m4(&self, arg: &'b isize) { }
|
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
| +++
help: consider introducing lifetime `'b` here
|
LL | fn m4<'b>(&self, arg: &'b isize) { }
| ++++
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
| +++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/regions-name-undeclared.rs:17:12
@ -37,12 +21,12 @@ LL | fn m5(&'b self) { }
|
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
| +++
help: consider introducing lifetime `'b` here
|
LL | fn m5<'b>(&'b self) { }
| ++++
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
| +++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/regions-name-undeclared.rs:18:27
@ -52,26 +36,54 @@ LL | fn m6(&self, arg: Foo<'b>) { }
|
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
| +++
help: consider introducing lifetime `'b` here
|
LL | fn m6<'b>(&self, arg: Foo<'b>) { }
| ++++
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
| +++
error[E0261]: use of undeclared lifetime name `'a`
error[E0401]: can't use generic parameters from outer item
--> $DIR/regions-name-undeclared.rs:26:22
|
LL | fn bar<'a>(x: &'a isize) {
| -- lifetime parameter from outer item
...
LL | type X = Option<&'a isize>;
| - ^^ undeclared lifetime
| - ^^ use of generic parameter from outer item
| |
| help: consider introducing lifetime `'a` here: `<'a>`
error[E0261]: use of undeclared lifetime name `'a`
error[E0401]: can't use generic parameters from outer item
--> $DIR/regions-name-undeclared.rs:28:13
|
LL | fn bar<'a>(x: &'a isize) {
| -- lifetime parameter from outer item
...
LL | enum E {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | E1(&'a isize)
| ^^ use of generic parameter from outer item
error[E0401]: can't use generic parameters from outer item
--> $DIR/regions-name-undeclared.rs:31:13
|
LL | fn bar<'a>(x: &'a isize) {
| -- lifetime parameter from outer item
...
LL | struct S {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | f: &'a isize
| ^^ use of generic parameter from outer item
error[E0401]: can't use generic parameters from outer item
--> $DIR/regions-name-undeclared.rs:33:14
|
LL | fn bar<'a>(x: &'a isize) {
| -- lifetime parameter from outer item
...
LL | fn f(a: &'a isize) { }
| - ^^ undeclared lifetime
| - ^^ use of generic parameter from outer item
| |
| help: consider introducing lifetime `'a` here: `<'a>`
@ -90,14 +102,14 @@ LL | ... &'b isize,
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'b` lifetime
|
LL | b: Box<dyn for<'b, 'a> FnOnce(&'a isize,
| +++
help: consider introducing lifetime `'b` here
|
LL | fn fn_types<'b>(a: &'a isize,
| ++++
help: consider making the bound lifetime-generic with a new `'b` lifetime
|
LL | b: Box<dyn for<'a, 'b> FnOnce(&'a isize,
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/regions-name-undeclared.rs:46:36
@ -105,15 +117,14 @@ error[E0261]: use of undeclared lifetime name `'b`
LL | ... &'b isize)>,
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'b` lifetime
|
LL | b: Box<dyn for<'b, 'a> FnOnce(&'a isize,
| +++
help: consider introducing lifetime `'b` here
|
LL | fn fn_types<'b>(a: &'a isize,
| ++++
help: consider making the bound lifetime-generic with a new `'b` lifetime
|
LL | b: Box<dyn for<'a, 'b> FnOnce(&'a isize,
| ++++
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:47:17
@ -132,13 +143,14 @@ LL | async fn buggy(&self) -> &'a str {
|
help: consider introducing lifetime `'a` here
|
LL | impl<'a> Bug {
| ++++
help: consider introducing lifetime `'a` here
|
LL | async fn buggy<'a>(&self) -> &'a str {
| ++++
help: consider introducing lifetime `'a` here
|
LL | impl<'a> Bug {
| ++++
error: aborting due to 12 previous errors
For more information about this error, try `rustc --explain E0261`.
Some errors have detailed explanations: E0261, E0401.
For more information about an error, try `rustc --explain E0261`.

8
src/test/ui/suggestions/fn-missing-lifetime-in-item.stderr
View File

@ -5,14 +5,14 @@ LL | struct S1<F: Fn(&i32, &i32) -> &'a i32>(F);
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider introducing lifetime `'a` here
|
LL | struct S1<'a, F: Fn(&i32, &i32) -> &'a i32>(F);
| +++
help: consider making the bound lifetime-generic with a new `'a` lifetime
|
LL | struct S1<F: for<'a> Fn(&i32, &i32) -> &'a i32>(F);
| +++++++
help: consider introducing lifetime `'a` here
|
LL | struct S1<'a, F: Fn(&i32, &i32) -> &'a i32>(F);
| +++
error[E0106]: missing lifetime specifier
--> $DIR/fn-missing-lifetime-in-item.rs:2:32

31
src/test/ui/suggestions/lifetimes/missing-lifetimes-in-signature.rs
View File

@ -14,28 +14,31 @@ fn get(self) -> usize {
fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce()
where
G: Get<T>
G: Get<T>,
{
move || {
//~^ ERROR hidden type for `impl Trait` captures lifetime
*dest = g.get();
}
}
// After applying suggestion for `foo`:
fn bar<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
//~^ ERROR the parameter type `G` may not live long enough
where
G: Get<T>
G: Get<T>,
{
//~^ ERROR the parameter type `G` may not live long enough
move || {
*dest = g.get();
}
}
// After applying suggestion for `bar`:
fn baz<G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ //~ ERROR undeclared lifetime
fn baz<G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
//~^ ERROR undeclared lifetime name `'a`
where
G: Get<T>
G: Get<T>,
{
move || {
*dest = g.get();
@ -44,9 +47,11 @@ fn baz<G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ //~ ERROR undeclared
// After applying suggestion for `baz`:
fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
//~^ ERROR the parameter type `G` may not live long enough
where
G: Get<T>
G: Get<T>,
{
//~^ ERROR the parameter type `G` may not live long enough
move || {
*dest = g.get();
}
@ -55,6 +60,8 @@ fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
// Same as above, but show that we pay attention to lifetime names from parent item
impl<'a> Foo {
fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
//~^ ERROR the parameter type `G` may not live long enough
//~| ERROR the parameter type `G` may not live long enough
move || {
*dest = g.get();
}
@ -63,8 +70,9 @@ fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
// After applying suggestion for `qux`:
fn bat<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
//~^ ERROR explicit lifetime required in the type of `dest`
where
G: Get<T>
G: Get<T>,
{
move || {
*dest = g.get();
@ -73,19 +81,20 @@ fn bat<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
// Potential incorrect attempt:
fn bak<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
//~^ ERROR the parameter type `G` may not live long enough
where
G: Get<T>
G: Get<T>,
{
//~^ ERROR the parameter type `G` may not live long enough
move || {
*dest = g.get();
}
}
// We need to tie the lifetime of `G` with the lifetime of `&mut T` and the returned closure:
fn ok<'a, G: 'a, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
where
G: Get<T>
G: Get<T>,
{
move || {
*dest = g.get();
@ -95,7 +104,7 @@ fn ok<'a, G: 'a, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
// This also works. The `'_` isn't necessary but it's where we arrive to following the suggestions:
fn ok2<'a, G: 'a, T>(g: G, dest: &'a mut T) -> impl FnOnce() + '_ + 'a
where
G: Get<T>
G: Get<T>,
{
move || {
*dest = g.get();

229
src/test/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
View File

@ -1,11 +1,234 @@
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/missing-lifetimes-in-signature.rs:36:11
--> $DIR/missing-lifetimes-in-signature.rs:38:11
|
LL | fn baz<G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `'a,`
error: aborting due to previous error
error[E0700]: hidden type for `impl Trait` captures lifetime that does not appear in bounds
--> $DIR/missing-lifetimes-in-signature.rs:19:5
|
LL | fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce()
| ------ hidden type `[closure@$DIR/missing-lifetimes-in-signature.rs:19:5: 22:6]` captures the anonymous lifetime defined here
...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^
|
help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
|
LL | fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ++++
For more information about this error, try `rustc --explain E0261`.
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:26:37
|
LL | fn bar<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^^^^^^^^^^^^^
|
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 `[closure@$DIR/missing-lifetimes-in-signature.rs:32:5: 34:6]` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:26:37
|
LL | fn bar<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^^^^^^^^^^^^^
help: consider introducing an explicit lifetime bound
|
LL | fn bar<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
| ~~~~~ ++++
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:30:1
|
LL | / {
LL | |
LL | | move || {
LL | | *dest = g.get();
LL | | }
LL | | }
| |_^
|
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 `[closure@$DIR/missing-lifetimes-in-signature.rs:32:5: 34:6]` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:30:1
|
LL | / {
LL | |
LL | | move || {
LL | | *dest = g.get();
LL | | }
LL | | }
| |_^
help: consider introducing an explicit lifetime bound
|
LL ~ fn bar<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
LL |
LL | where
LL | G: Get<T>,
LL | {
LL |
...
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:49:45
|
LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^^^^^^^^^^^^^
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:49:34
|
LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^
note: ...so that the type `[closure@$DIR/missing-lifetimes-in-signature.rs:55:5: 57:6]` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:49:45
|
LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^^^^^^^^^^^^^
help: consider introducing an explicit lifetime bound
|
LL | fn qux<'b, 'a, G: 'b + 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'b
| +++ ~~~~~~~ ++++
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:53:1
|
LL | / {
LL | |
LL | | move || {
LL | | *dest = g.get();
LL | | }
LL | | }
| |_^
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:49:34
|
LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
| ^^^^^^
note: ...so that the type `[closure@$DIR/missing-lifetimes-in-signature.rs:55:5: 57:6]` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:53:1
|
LL | / {
LL | |
LL | | move || {
LL | | *dest = g.get();
LL | | }
LL | | }
| |_^
help: consider introducing an explicit lifetime bound
|
LL ~ fn qux<'b, 'a, G: 'b + 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
LL |
LL | where
LL | G: Get<T>,
LL | {
LL |
...
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:62:58
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| ^^^^^^^^^^^^^^^^^^
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:62:47
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| ^^^^^^
note: ...so that the type `[closure@$DIR/missing-lifetimes-in-signature.rs:65:9: 67:10]` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:62:58
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| ^^^^^^^^^^^^^^^^^^
help: consider introducing an explicit lifetime bound
|
LL | fn qux<'c, 'b, G: 'c + Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'c {
| +++ ~~~~~~~ ++++
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:62:77
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| _____________________________________________________________________________^
LL | |
LL | |
LL | | move || {
LL | | *dest = g.get();
LL | | }
LL | | }
| |_____^
|
note: the parameter type `G` must be valid for the anonymous lifetime defined here...
--> $DIR/missing-lifetimes-in-signature.rs:62:47
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| ^^^^^^
note: ...so that the type `[closure@$DIR/missing-lifetimes-in-signature.rs:65:9: 67:10]` will meet its required lifetime bounds
--> $DIR/missing-lifetimes-in-signature.rs:62:77
|
LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
| _____________________________________________________________________________^
LL | |
LL | |
LL | | move || {
LL | | *dest = g.get();
LL | | }
LL | | }
| |_____^
help: consider introducing an explicit lifetime bound
|
LL ~ fn qux<'c, 'b, G: 'c + Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
LL |
LL |
LL | move || {
LL | *dest = g.get();
LL | }
...
error[E0621]: explicit lifetime required in the type of `dest`
--> $DIR/missing-lifetimes-in-signature.rs:72:45
|
LL | fn bat<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
| ------ ^^^^^^^^^^^^^^^^^^^^^^^ lifetime `'a` required
| |
| help: add explicit lifetime `'a` to the type of `dest`: `&'a mut T`
error[E0309]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:83:44
|
LL | fn bak<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
| - ^^^^^^^^^^^^^^^^^^ ...so that the type `[closure@$DIR/missing-lifetimes-in-signature.rs:89:5: 91:6]` will meet its required lifetime bounds
| |
| help: consider adding an explicit lifetime bound...: `G: 'a`
error[E0309]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:87:1
|
LL | fn bak<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
| - help: consider adding an explicit lifetime bound...: `G: 'a`
...
LL | / {
LL | |
LL | | move || {
LL | | *dest = g.get();
LL | | }
LL | | }
| |_^ ...so that the type `[closure@$DIR/missing-lifetimes-in-signature.rs:89:5: 91:6]` will meet its required lifetime bounds
error: aborting due to 11 previous errors
Some errors have detailed explanations: E0261, E0309, E0621, E0700.
For more information about an error, try `rustc --explain E0261`.

2
src/test/ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-error.rs
View File

@ -18,5 +18,7 @@ impl<T> WithAssoc<T> for () {
//~^ ERROR use of undeclared lifetime name `'a`
fn my_fun() -> Return<()> {}
//~^ ERROR non-defining opaque type use in defining scope
//~| ERROR non-defining opaque type use in defining scope
fn main() {}

40
src/test/ui/type-alias-impl-trait/issue-69136-inner-lifetime-resolve-error.stderr
View File

@ -2,10 +2,42 @@ error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/issue-69136-inner-lifetime-resolve-error.rs:17:65
|
LL | type Return<A> = impl WithAssoc<A, AssocType = impl SomeTrait + 'a>;
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `'a,`
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'a` lifetime
|
LL | type Return<A> = impl for<'a> WithAssoc<A, AssocType = impl SomeTrait + 'a>;
| +++++++
help: consider introducing lifetime `'a` here
|
LL | type Return<'a, A> = impl WithAssoc<A, AssocType = impl SomeTrait + 'a>;
| +++
error: aborting due to previous error
error: non-defining opaque type use in defining scope
--> $DIR/issue-69136-inner-lifetime-resolve-error.rs:20:27
|
LL | fn my_fun() -> Return<()> {}
| ^^
|
note: used non-generic type `()` for generic parameter
--> $DIR/issue-69136-inner-lifetime-resolve-error.rs:17:13
|
LL | type Return<A> = impl WithAssoc<A, AssocType = impl SomeTrait + 'a>;
| ^
error: non-defining opaque type use in defining scope
--> $DIR/issue-69136-inner-lifetime-resolve-error.rs:20:27
|
LL | fn my_fun() -> Return<()> {}
| ^^
|
note: used non-generic type `()` for generic parameter
--> $DIR/issue-69136-inner-lifetime-resolve-error.rs:17:13
|
LL | type Return<A> = impl WithAssoc<A, AssocType = impl SomeTrait + 'a>;
| ^
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0261`.

8
src/test/ui/underscore-lifetime/in-binder.rs
View File

@ -10,22 +10,22 @@ impl<'_> IceCube<'_> {}
//~^ ERROR `'_` cannot be used here
struct Struct<'_> {
//~^ ERROR `'_` cannot be used here
//~^ ERROR `'_` cannot be used here
v: Vec<&'static char>
}
enum Enum<'_> {
//~^ ERROR `'_` cannot be used here
//~^ ERROR `'_` cannot be used here
Variant
}
union Union<'_> {
//~^ ERROR `'_` cannot be used here
//~^ ERROR `'_` cannot be used here
a: u32
}
trait Trait<'_> {
//~^ ERROR `'_` cannot be used here
//~^ ERROR `'_` cannot be used here
}
fn foo<'_>() {

33
src/test/ui/where-clauses/where-lifetime-resolution.stderr
View File

@ -1,20 +1,41 @@
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/where-lifetime-resolution.rs:6:38
|
LL | fn f() where
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | for<'a> dyn Trait1<'a>: Trait1<'a>, // OK
LL | (dyn for<'a> Trait1<'a>): Trait1<'a>,
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider making the bound lifetime-generic with a new `'a` lifetime
|
LL | (dyn for<'a> Trait1<'a>): for<'a> Trait1<'a>,
| +++++++
help: consider making the bound lifetime-generic with a new `'a` lifetime
|
LL | for<'a> (dyn for<'a> Trait1<'a>): Trait1<'a>,
| +++++++
help: consider introducing lifetime `'a` here
|
LL | fn f<'a>() where
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/where-lifetime-resolution.rs:8:52
|
LL | fn f() where
| - help: consider introducing lifetime `'b` here: `<'b>`
...
LL | for<'a> dyn for<'b> Trait2<'a, 'b>: Trait2<'a, 'b>,
| ^^ undeclared lifetime
|
help: consider making the bound lifetime-generic with a new `'b` lifetime
|
LL | for<'a> dyn for<'b> Trait2<'a, 'b>: for<'b> Trait2<'a, 'b>,
| +++++++
help: consider making the bound lifetime-generic with a new `'b` lifetime
|
LL | for<'b, 'a> dyn for<'b> Trait2<'a, 'b>: Trait2<'a, 'b>,
| +++
help: consider introducing lifetime `'b` here
|
LL | fn f<'b>() where
| ++++
error: aborting due to 2 previous errors