Rollup merge of #93845 - compiler-errors:in-band-lifetimes, r=cjgillot

Remove in band lifetimes

As discussed in t-lang backlog bonanza, the `in_band_lifetimes` FCP closed in favor for the feature not being stabilized. This PR removes `#![feature(in_band_lifetimes)]` in its entirety.

Let me know if this PR is too hasty, and if we should instead do something intermediate for deprecate the feature first.

r? `@scottmcm` (or feel free to reassign, just saw your last comment on #44524)
Closes #44524
This commit is contained in:
Matthias Krüger 2022-02-25 14:14:35 +01:00 committed by GitHub
commit ec4fc726b0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
71 changed files with 99 additions and 1538 deletions

View file

@ -193,8 +193,8 @@ impl Clean<Lifetime> for hir::Lifetime {
fn clean(&self, cx: &mut DocContext<'_>) -> Lifetime {
let def = cx.tcx.named_region(self.hir_id);
if let Some(
rl::Region::EarlyBound(_, node_id, _)
| rl::Region::LateBound(_, _, node_id, _)
rl::Region::EarlyBound(_, node_id)
| rl::Region::LateBound(_, _, node_id)
| rl::Region::Free(_, node_id),
) = def
{

View file

@ -2,8 +2,6 @@
// edition:2018
// compile-flags: --crate-type lib
#![feature(in_band_lifetimes)]
use std::future::Future;
pub async fn simple_generic<T>() {}
@ -73,10 +71,6 @@ pub fn call_with_ref_block<'a>(f: &'a (impl Foo + 'a)) -> impl Future<Output = (
async move { f.foo() }
}
pub fn call_with_ref_block_in_band(f: &'a (impl Foo + 'a)) -> impl Future<Output = ()> + 'a {
async move { f.foo() }
}
pub fn async_block_with_same_generic_params_unifies() {
let mut a = call_generic_bound_block(FooType);
a = call_generic_bound_block(FooType);
@ -91,9 +85,4 @@ pub fn async_block_with_same_generic_params_unifies() {
let f_two = FooType;
let mut d = call_with_ref_block(&f_one);
d = call_with_ref_block(&f_two);
let f_one = FooType;
let f_two = FooType;
let mut d = call_with_ref_block_in_band(&f_one);
d = call_with_ref_block_in_band(&f_two);
}

View file

@ -5,8 +5,6 @@ LL | fn foo(x: &'a str) { }
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/E0261.rs:5:9
@ -15,8 +13,6 @@ LL | struct Foo {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | x: &'a str,
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors

View file

@ -1,62 +0,0 @@
#![allow(warnings)]
fn foo(x: &'x u8) -> &'x u8 { x }
//~^ ERROR use of undeclared lifetime name
//~^^ ERROR use of undeclared lifetime name
struct X<'a>(&'a u8);
impl<'a> X<'a> {
fn inner(&self) -> &'a u8 {
self.0
}
}
impl<'a> X<'b> {
//~^ ERROR use of undeclared lifetime name
fn inner_2(&self) -> &'b u8 {
//~^ ERROR use of undeclared lifetime name
self.0
}
}
impl X<'b> {
//~^ ERROR use of undeclared lifetime name
fn inner_3(&self) -> &'b u8 {
//~^ ERROR use of undeclared lifetime name
self.0
}
}
struct Y<T>(T);
impl Y<&'a u8> {
//~^ ERROR use of undeclared lifetime name
fn inner(&self) -> &'a u8 {
//~^ ERROR use of undeclared lifetime name
self.0
}
}
trait MyTrait<'a> {
fn my_lifetime(&self) -> &'a u8;
fn any_lifetime() -> &'b u8;
//~^ ERROR use of undeclared lifetime name
fn borrowed_lifetime(&'b self) -> &'b u8;
//~^ ERROR use of undeclared lifetime name
//~^^ ERROR use of undeclared lifetime name
}
impl MyTrait<'a> for Y<&'a u8> {
//~^ ERROR use of undeclared lifetime name
//~^^ ERROR use of undeclared lifetime name
fn my_lifetime(&self) -> &'a u8 { self.0 }
//~^ ERROR use of undeclared lifetime name
fn any_lifetime() -> &'b u8 { &0 }
//~^ ERROR use of undeclared lifetime name
fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 }
//~^ ERROR use of undeclared lifetime name
//~^^ ERROR use of undeclared lifetime name
}
fn main() {}

View file

@ -1,231 +0,0 @@
error[E0261]: use of undeclared lifetime name `'x`
--> $DIR/feature-gate-in_band_lifetimes.rs:3:12
|
LL | fn foo(x: &'x u8) -> &'x u8 { x }
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'x` here: `<'x>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'x`
--> $DIR/feature-gate-in_band_lifetimes.rs:3:23
|
LL | fn foo(x: &'x u8) -> &'x u8 { x }
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'x` here: `<'x>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:15:12
|
LL | impl<'a> X<'b> {
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'b` here: `'b,`
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:17:27
|
LL | fn inner_2(&self) -> &'b u8 {
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> X<'b> {
| +++
help: consider introducing lifetime `'b` here
|
LL | fn inner_2<'b>(&self) -> &'b u8 {
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:23:8
|
LL | impl X<'b> {
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'b` here: `<'b>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:25:27
|
LL | fn inner_3(&self) -> &'b u8 {
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> X<'b> {
| ++++
help: consider introducing lifetime `'b` here
|
LL | fn inner_3<'b>(&self) -> &'b u8 {
| ++++
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:33:9
|
LL | impl Y<&'a u8> {
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:35:25
|
LL | fn inner(&self) -> &'a u8 {
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'a` here
|
LL | impl<'a> Y<&'a u8> {
| ++++
help: consider introducing lifetime `'a` here
|
LL | fn inner<'a>(&self) -> &'a u8 {
| ++++
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:50:14
|
LL | impl MyTrait<'a> for Y<&'a u8> {
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:50:25
|
LL | impl MyTrait<'a> for Y<&'a u8> {
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/feature-gate-in_band_lifetimes.rs:53:31
|
LL | fn my_lifetime(&self) -> &'a u8 { self.0 }
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'a` here
|
LL | impl<'a> MyTrait<'a> for Y<&'a u8> {
| ++++
help: consider introducing lifetime `'a` here
|
LL | fn my_lifetime<'a>(&self) -> &'a u8 { self.0 }
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:55:27
|
LL | fn any_lifetime() -> &'b u8 { &0 }
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> MyTrait<'a> for Y<&'a u8> {
| ++++
help: consider introducing lifetime `'b` here
|
LL | fn any_lifetime<'b>() -> &'b u8 { &0 }
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:57:27
|
LL | fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 }
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> MyTrait<'a> for Y<&'a u8> {
| ++++
help: consider introducing lifetime `'b` here
|
LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8 { &*self.0 }
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:57:40
|
LL | fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 }
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> MyTrait<'a> for Y<&'a u8> {
| ++++
help: consider introducing lifetime `'b` here
|
LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8 { &*self.0 }
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:43:27
|
LL | fn any_lifetime() -> &'b u8;
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait MyTrait<'b, 'a> {
| +++
help: consider introducing lifetime `'b` here
|
LL | fn any_lifetime<'b>() -> &'b u8;
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:45:27
|
LL | fn borrowed_lifetime(&'b self) -> &'b u8;
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait MyTrait<'b, 'a> {
| +++
help: consider introducing lifetime `'b` here
|
LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8;
| ++++
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/feature-gate-in_band_lifetimes.rs:45:40
|
LL | fn borrowed_lifetime(&'b self) -> &'b u8;
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait MyTrait<'b, 'a> {
| +++
help: consider introducing lifetime `'b` here
|
LL | fn borrowed_lifetime<'b>(&'b self) -> &'b u8;
| ++++
error: aborting due to 17 previous errors
For more information about this error, try `rustc --explain E0261`.

View file

@ -5,8 +5,6 @@ LL | fn _f(arg : Box<dyn for<'a> X<Y<'x> = &'a [u32]>>) {}
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'x` here: `<'x>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
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

View file

@ -4,7 +4,6 @@ error[E0261]: use of undeclared lifetime name `'b`
LL | + Deref<Target = Self::Item<'b>>;
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | trait Iterable<'b> {
@ -20,7 +19,6 @@ error[E0261]: use of undeclared lifetime name `'undeclared`
LL | fn iter<'a>(&'a self) -> Self::Iter<'undeclared>;
| ^^^^^^^^^^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'undeclared` here
|
LL | trait Iterable<'undeclared> {

View file

@ -5,8 +5,6 @@ LL | fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {}
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/issue-67510.rs:7:26
@ -15,8 +13,6 @@ LL | fn f(x: Box<dyn X<Y<'a>=&'a ()>>) {}
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors

View file

@ -8,9 +8,8 @@
// run-pass
#![allow(dead_code)]
#![feature(in_band_lifetimes)]
fn foo(x: &'x u32) -> impl Fn() -> &'y u32
fn foo<'x, 'y>(x: &'x u32) -> impl Fn() -> &'y u32
where 'x: 'y
{
move || x

View file

@ -8,13 +8,12 @@
// run-pass
#![allow(dead_code)]
#![feature(in_band_lifetimes)]
trait Trait<'a> { }
impl Trait<'b> for &'a u32 { }
impl<'a, 'b> Trait<'b> for &'a u32 { }
fn foo(x: &'x u32) -> impl Trait<'y>
fn foo<'x, 'y>(x: &'x u32) -> impl Trait<'y>
where 'x: 'y
{
x

View file

@ -4,15 +4,14 @@
// See https://github.com/rust-lang/rust/issues/46541 for more details.
#![allow(dead_code)]
#![feature(in_band_lifetimes)]
use std::cell::Cell;
trait Trait<'a> { }
impl Trait<'b> for Cell<&'a u32> { }
impl<'a, 'b> Trait<'b> for Cell<&'a u32> { }
fn foo(x: Cell<&'x u32>) -> impl Trait<'y>
fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y>
//~^ ERROR hidden type for `impl Trait` captures lifetime that does not appear in bounds [E0700]
where 'x: 'y
{

View file

@ -1,16 +1,15 @@
error[E0700]: hidden type for `impl Trait` captures lifetime that does not appear in bounds
--> $DIR/region-escape-via-bound.rs:15:29
--> $DIR/region-escape-via-bound.rs:14:37
|
LL | fn foo(x: Cell<&'x u32>) -> impl Trait<'y>
| ^^^^^^^^^^^^^^
LL |
LL | where 'x: 'y
| -- hidden type `Cell<&'x u32>` captures the lifetime `'x` as defined here
LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y>
| -- ^^^^^^^^^^^^^^
| |
| hidden type `Cell<&'x u32>` captures the lifetime `'x` as defined here
|
help: to declare that the `impl Trait` captures `'x`, you can add an explicit `'x` lifetime bound
|
LL | fn foo(x: Cell<&'x u32>) -> impl Trait<'y> + 'x
| ++++
LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x
| ++++
error: aborting due to previous error

View file

@ -1,16 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
fn foo(x: fn(&'a u32)) {} //~ ERROR must be explicitly
fn bar(x: &Fn(&'a u32)) {} //~ ERROR must be explicitly
fn baz(x: fn(&'a u32), y: &'a u32) {} //~ ERROR must be explicitly
struct Foo<'a> { x: &'a u32 }
impl Foo<'a> {
fn bar(&self, x: fn(&'a u32)) {} //~ ERROR must be explicitly
}
fn main() {}

View file

@ -1,27 +0,0 @@
error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders
--> $DIR/E0687.rs:4:15
|
LL | fn foo(x: fn(&'a u32)) {}
| ^^ in-band lifetime definition
error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders
--> $DIR/E0687.rs:6:16
|
LL | fn bar(x: &Fn(&'a u32)) {}
| ^^ in-band lifetime definition
error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders
--> $DIR/E0687.rs:8:15
|
LL | fn baz(x: fn(&'a u32), y: &'a u32) {}
| ^^ in-band lifetime definition
error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders
--> $DIR/E0687.rs:13:26
|
LL | fn bar(&self, x: fn(&'a u32)) {}
| ^^ in-band lifetime definition
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0687`.

View file

@ -1,8 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
fn bar<F>(x: &F) where F: Fn(&'a u32) {} //~ ERROR must be explicitly
fn baz(x: &impl Fn(&'a u32)) {} //~ ERROR must be explicitly
fn main() {}

View file

@ -1,15 +0,0 @@
error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders
--> $DIR/E0687_where.rs:4:31
|
LL | fn bar<F>(x: &F) where F: Fn(&'a u32) {}
| ^^ in-band lifetime definition
error[E0687]: lifetimes used in `fn` or `Fn` syntax must be explicitly declared using `<...>` binders
--> $DIR/E0687_where.rs:6:21
|
LL | fn baz(x: &impl Fn(&'a u32)) {}
| ^^ in-band lifetime definition
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0687`.

View file

@ -1,16 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
fn foo<'a>(x: &'a u32, y: &'b u32) {} //~ ERROR cannot mix
struct Foo<'a> { x: &'a u32 }
impl Foo<'a> {
fn bar<'b>(x: &'a u32, y: &'b u32, z: &'c u32) {} //~ ERROR cannot mix
}
impl<'b> Foo<'a> { //~ ERROR cannot mix
fn baz() {}
}
fn main() {}

View file

@ -1,27 +0,0 @@
error[E0688]: cannot mix in-band and explicit lifetime definitions
--> $DIR/E0688.rs:4:28
|
LL | fn foo<'a>(x: &'a u32, y: &'b u32) {}
| -- ^^ in-band lifetime definition here
| |
| explicit lifetime definition here
error[E0688]: cannot mix in-band and explicit lifetime definitions
--> $DIR/E0688.rs:9:44
|
LL | fn bar<'b>(x: &'a u32, y: &'b u32, z: &'c u32) {}
| -- ^^ in-band lifetime definition here
| |
| explicit lifetime definition here
error[E0688]: cannot mix in-band and explicit lifetime definitions
--> $DIR/E0688.rs:12:14
|
LL | impl<'b> Foo<'a> {
| -- ^^ in-band lifetime definition here
| |
| explicit lifetime definition here
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0688`.

View file

@ -1,119 +0,0 @@
// run-rustfix
// edition:2018
#![allow(unused)]
#![deny(elided_lifetimes_in_paths)]
//~^ NOTE the lint level is defined here
use std::cell::{Ref, RefCell};
struct Foo<'a> {
x: &'a u32,
}
fn foo(x: &Foo<'_>) {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
}
fn bar(x: &Foo<'_>) {}
struct Wrapped<'a>(&'a str);
struct WrappedWithBow<'a> {
gift: &'a str,
}
struct MatchedSet<'a, 'b> {
one: &'a str,
another: &'b str,
}
fn wrap_gift(gift: &str) -> Wrapped<'_> {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
Wrapped(gift)
}
fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow<'_> {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
WrappedWithBow { gift }
}
fn inspect_matched_set(set: MatchedSet<'_, '_>) {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected 2 lifetime parameters
//~| HELP consider using the `'_` lifetime
println!("{} {}", set.one, set.another);
}
// Verify that the lint does not fire, because the added `'_` wouldn't be resolved correctly.
fn match_sets() -> MatchedSet<'static, 'static> {
//~^ ERROR missing lifetime specifiers
//~| NOTE expected 2 lifetime parameters
//~| HELP this function's return type contains a borrowed value
//~| HELP consider using the `'static` lifetime
MatchedSet { one: "one", another: "another" }
}
macro_rules! autowrapper {
($type_name:ident, $fn_name:ident, $lt:lifetime) => {
struct $type_name<$lt> {
gift: &$lt str
}
fn $fn_name(gift: &str) -> $type_name<'_> {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
//~| ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
$type_name { gift }
}
}
}
autowrapper!(Autowrapped, autowrap_gift, 'a);
//~^ NOTE in this expansion of autowrapper!
//~| NOTE in this expansion of autowrapper!
// Verify that rustfix does not try to apply the fix twice.
autowrapper!(AutowrappedAgain, autowrap_gift_again, 'a);
//~^ NOTE in this expansion of autowrapper!
//~| NOTE in this expansion of autowrapper!
macro_rules! anytuple_ref_ty {
($($types:ty),*) => {
Ref<'_, ($($types),*)>
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
}
}
#[allow(elided_lifetimes_in_paths)]
mod blah {
struct Thing<'a>(&'a i32);
struct Bar<T>(T);
fn foo(b: Bar<Thing>) {}
}
fn main() {
let honesty = RefCell::new((4, 'e'));
let loyalty: Ref<'_, (u32, char)> = honesty.borrow();
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
let generosity = Ref::map(loyalty, |t| &t.0);
let laughter = RefCell::new((true, "magic"));
let yellow: anytuple_ref_ty!(bool, &str) = laughter.borrow();
//~^ NOTE in this expansion of anytuple_ref_ty!
//~| NOTE in this expansion of anytuple_ref_ty!
}

View file

@ -1,119 +0,0 @@
// run-rustfix
// edition:2018
#![allow(unused)]
#![deny(elided_lifetimes_in_paths)]
//~^ NOTE the lint level is defined here
use std::cell::{Ref, RefCell};
struct Foo<'a> {
x: &'a u32,
}
fn foo(x: &Foo) {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
}
fn bar(x: &Foo<'_>) {}
struct Wrapped<'a>(&'a str);
struct WrappedWithBow<'a> {
gift: &'a str,
}
struct MatchedSet<'a, 'b> {
one: &'a str,
another: &'b str,
}
fn wrap_gift(gift: &str) -> Wrapped {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
Wrapped(gift)
}
fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
WrappedWithBow { gift }
}
fn inspect_matched_set(set: MatchedSet) {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected 2 lifetime parameters
//~| HELP consider using the `'_` lifetime
println!("{} {}", set.one, set.another);
}
// Verify that the lint does not fire, because the added `'_` wouldn't be resolved correctly.
fn match_sets() -> MatchedSet {
//~^ ERROR missing lifetime specifiers
//~| NOTE expected 2 lifetime parameters
//~| HELP this function's return type contains a borrowed value
//~| HELP consider using the `'static` lifetime
MatchedSet { one: "one", another: "another" }
}
macro_rules! autowrapper {
($type_name:ident, $fn_name:ident, $lt:lifetime) => {
struct $type_name<$lt> {
gift: &$lt str
}
fn $fn_name(gift: &str) -> $type_name {
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
//~| ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
$type_name { gift }
}
}
}
autowrapper!(Autowrapped, autowrap_gift, 'a);
//~^ NOTE in this expansion of autowrapper!
//~| NOTE in this expansion of autowrapper!
// Verify that rustfix does not try to apply the fix twice.
autowrapper!(AutowrappedAgain, autowrap_gift_again, 'a);
//~^ NOTE in this expansion of autowrapper!
//~| NOTE in this expansion of autowrapper!
macro_rules! anytuple_ref_ty {
($($types:ty),*) => {
Ref<($($types),*)>
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
}
}
#[allow(elided_lifetimes_in_paths)]
mod blah {
struct Thing<'a>(&'a i32);
struct Bar<T>(T);
fn foo(b: Bar<Thing>) {}
}
fn main() {
let honesty = RefCell::new((4, 'e'));
let loyalty: Ref<(u32, char)> = honesty.borrow();
//~^ ERROR hidden lifetime parameters in types are deprecated
//~| NOTE expected named lifetime parameter
//~| HELP consider using the `'_` lifetime
let generosity = Ref::map(loyalty, |t| &t.0);
let laughter = RefCell::new((true, "magic"));
let yellow: anytuple_ref_ty!(bool, &str) = laughter.borrow();
//~^ NOTE in this expansion of anytuple_ref_ty!
//~| NOTE in this expansion of anytuple_ref_ty!
}

View file

@ -1,120 +0,0 @@
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:14:12
|
LL | fn foo(x: &Foo) {
| ^^^ expected named lifetime parameter
|
note: the lint level is defined here
--> $DIR/elided-lifetimes.rs:5:9
|
LL | #![deny(elided_lifetimes_in_paths)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider using the `'_` lifetime
|
LL | fn foo(x: &Foo<'_>) {
| ~~~~~~~
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:33:29
|
LL | fn wrap_gift(gift: &str) -> Wrapped {
| ^^^^^^^ expected named lifetime parameter
|
help: consider using the `'_` lifetime
|
LL | fn wrap_gift(gift: &str) -> Wrapped<'_> {
| ~~~~~~~~~~~
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:40:38
|
LL | fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow {
| ^^^^^^^^^^^^^^ expected named lifetime parameter
|
help: consider using the `'_` lifetime
|
LL | fn wrap_gift_with_bow(gift: &str) -> WrappedWithBow<'_> {
| ~~~~~~~~~~~~~~~~~~
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:47:29
|
LL | fn inspect_matched_set(set: MatchedSet) {
| ^^^^^^^^^^ expected 2 lifetime parameters
|
help: consider using the `'_` lifetime
|
LL | fn inspect_matched_set(set: MatchedSet<'_, '_>) {
| ~~~~~~~~~~~~~~~~~~
error[E0106]: missing lifetime specifiers
--> $DIR/elided-lifetimes.rs:55:20
|
LL | fn match_sets() -> MatchedSet {
| ^^^^^^^^^^ expected 2 lifetime parameters
|
= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime
|
LL | fn match_sets() -> MatchedSet<'static, 'static> {
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:69:36
|
LL | fn $fn_name(gift: &str) -> $type_name {
| ^^^^^^^^^^ expected named lifetime parameter
...
LL | autowrapper!(Autowrapped, autowrap_gift, 'a);
| -------------------------------------------- in this macro invocation
|
= note: this error originates in the macro `autowrapper` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider using the `'_` lifetime
|
LL | fn $fn_name(gift: &str) -> $type_name<'_> {
| ~~~~~~~~~~~~~~
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:69:36
|
LL | fn $fn_name(gift: &str) -> $type_name {
| ^^^^^^^^^^ expected named lifetime parameter
...
LL | autowrapper!(AutowrappedAgain, autowrap_gift_again, 'a);
| ------------------------------------------------------- in this macro invocation
|
= note: this error originates in the macro `autowrapper` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider using the `'_` lifetime
|
LL | fn $fn_name(gift: &str) -> $type_name<'_> {
| ~~~~~~~~~~~~~~
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:109:22
|
LL | let loyalty: Ref<(u32, char)> = honesty.borrow();
| ^ expected named lifetime parameter
|
help: consider using the `'_` lifetime
|
LL | let loyalty: Ref<'_, (u32, char)> = honesty.borrow();
| +++
error: hidden lifetime parameters in types are deprecated
--> $DIR/elided-lifetimes.rs:92:13
|
LL | Ref<($($types),*)>
| ^ expected named lifetime parameter
...
LL | let yellow: anytuple_ref_ty!(bool, &str) = laughter.borrow();
| ---------------------------- in this macro invocation
|
= note: this error originates in the macro `anytuple_ref_ty` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider using the `'_` lifetime
|
LL | Ref<'_, ($($types),*)>
| +++
error: aborting due to 9 previous errors
For more information about this error, try `rustc --explain E0106`.

View file

@ -1,96 +0,0 @@
// run-pass
#![allow(warnings)]
#![feature(in_band_lifetimes)]
fn foo(x: &'x u8) -> &'x u8 { x }
fn foo2(x: &'a u8, y: &u8) -> &'a u8 { x }
fn check_in_band_can_be_late_bound() {
let _: for<'x> fn(&'x u8, &u8) -> &'x u8 = foo2;
}
struct ForInherentNoParams;
impl ForInherentNoParams {
fn foo(x: &'a u32, y: &u32) -> &'a u32 { x }
}
struct X<'a>(&'a u8);
impl<'a> X<'a> {
fn inner(&self) -> &'a u8 {
self.0
}
fn same_lifetime_as_parameter(&mut self, x: &'a u8) {
self.0 = x;
}
}
impl X<'b> {
fn inner_2(&self) -> &'b u8 {
self.0
}
fn reference_already_introduced_in_band_from_method_with_explicit_binders<'a>(
&'b self, x: &'a u32
) {}
}
struct Y<T>(T);
impl Y<&'a u8> {
fn inner(&self) -> &'a u8 {
self.0
}
}
trait MyTrait<'a> {
fn my_lifetime(&self) -> &'a u8;
fn any_lifetime() -> &'b u8;
fn borrowed_lifetime(&'b self) -> &'b u8;
fn default_impl(&self, x: &'b u32, y: &u32) -> &'b u32 { x }
fn in_band_def_explicit_impl(&self, x: &'b u8);
}
impl MyTrait<'a> for Y<&'a u8> {
fn my_lifetime(&self) -> &'a u8 { self.0 }
fn any_lifetime() -> &'b u8 { &0 }
fn borrowed_lifetime(&'b self) -> &'b u8 { &*self.0 }
fn in_band_def_explicit_impl<'b>(&self, x: &'b u8) {}
}
fn test_hrtb_defined_lifetime_where<F>(_: F) where for<'a> F: Fn(&'a u8) {}
fn test_hrtb_defined_lifetime_polytraitref<F>(_: F) where F: for<'a> Fn(&'a u8) {}
fn reference_in_band_from_locals(x: &'test u32) -> &'test u32 {
let y: &'test u32 = x;
y
}
fn in_generics_in_band<T: MyTrait<'a>>(x: &T) {}
fn where_clause_in_band<T>(x: &T) where T: MyTrait<'a> {}
fn impl_trait_in_band(x: &impl MyTrait<'a>) {}
// Tests around using in-band lifetimes within existential traits.
trait FunkyTrait<'a> { }
impl<'a, T> FunkyTrait<'a> for T { }
fn ret_pos_impl_trait_in_band_outlives(x: &'a u32) -> impl ::std::fmt::Debug + 'a {
x
}
fn ret_pos_impl_trait_in_band_param(x: &'a u32) -> impl FunkyTrait<'a> {
x
}
fn ret_pos_impl_trait_in_band_param_static(x: &'a u32) -> impl FunkyTrait<'static> + 'a {
x
}
fn ret_pos_impl_trait_in_band_param_outlives(x: &'a u32) -> impl FunkyTrait<'a> + 'a {
x
}
fn ret_pos_impl_trait_in_band_higher_ranked(x: &'a u32) -> impl for<'b> FunkyTrait<'b> + 'a {
x
}
fn main() {}

View file

@ -1,10 +0,0 @@
#![deny(elided_lifetimes_in_paths)]
// Previously, the elided-lifetimes-in-path lint would fire, but we don't want
// that, because `'_` isn't legal in struct declarations.
struct Betrayal<'a> { x: &'a u8 }
struct Heartbreak(Betrayal); //~ ERROR missing lifetime specifier
fn main() {}

View file

@ -1,14 +0,0 @@
error[E0106]: missing lifetime specifier
--> $DIR/issue-61124-anon-lifetime-in-struct-declaration.rs:8:19
|
LL | struct Heartbreak(Betrayal);
| ^^^^^^^^ expected named lifetime parameter
|
help: consider introducing a named lifetime parameter
|
LL | struct Heartbreak<'a>(Betrayal<'a>);
| ++++ ~~~~~~~~~~~~
error: aborting due to previous error
For more information about this error, try `rustc --explain E0106`.

View file

@ -1,22 +0,0 @@
error[E0621]: explicit lifetime required in the type of `y`
--> $DIR/mismatched.rs:4:42
|
LL | fn foo(x: &'a u32, y: &u32) -> &'a u32 { y }
| ---- ^ lifetime `'a` required
| |
| help: add explicit lifetime `'a` to the type of `y`: `&'a u32`
error: lifetime may not live long enough
--> $DIR/mismatched.rs:6:46
|
LL | fn foo2(x: &'a u32, y: &'b u32) -> &'a u32 { y }
| -- -- ^ function was supposed to return data with lifetime `'a` but it is returning data with lifetime `'b`
| | |
| | lifetime `'b` defined here
| lifetime `'a` defined here
|
= help: consider adding the following bound: `'b: 'a`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0621`.

View file

@ -1,8 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
fn foo(x: &'a u32, y: &u32) -> &'a u32 { y } //~ ERROR explicit lifetime required
fn foo2(x: &'a u32, y: &'b u32) -> &'a u32 { y } //~ ERROR lifetime mismatch
fn main() {}

View file

@ -1,20 +0,0 @@
error[E0621]: explicit lifetime required in the type of `y`
--> $DIR/mismatched.rs:4:42
|
LL | fn foo(x: &'a u32, y: &u32) -> &'a u32 { y }
| ---- ^ lifetime `'a` required
| |
| help: add explicit lifetime `'a` to the type of `y`: `&'a u32`
error[E0623]: lifetime mismatch
--> $DIR/mismatched.rs:6:46
|
LL | fn foo2(x: &'a u32, y: &'b u32) -> &'a u32 { y }
| ------- ------- ^ ...but data from `y` is returned here
| |
| this parameter and the return type are declared with different lifetimes...
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0621, E0623.
For more information about an error, try `rustc --explain E0621`.

View file

@ -1,10 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
trait Get {
fn baz(&self, x: &'a u32, y: &u32) -> &'a u32 {
y //~ ERROR explicit lifetime required
}
}
fn main() {}

View file

@ -1,11 +0,0 @@
error[E0621]: explicit lifetime required in the type of `y`
--> $DIR/mismatched_trait.rs:6:9
|
LL | fn baz(&self, x: &'a u32, y: &u32) -> &'a u32 {
| ---- help: add explicit lifetime `'a` to the type of `y`: `&'a u32`
LL | y
| ^ lifetime `'a` required
error: aborting due to previous error
For more information about this error, try `rustc --explain E0621`.

View file

@ -1,14 +0,0 @@
use std::ops::Deref;
trait Trait {}
struct Struct;
impl Deref for Struct {
type Target = dyn Trait;
fn deref(&self) -> &dyn Trait {
//~^ ERROR `impl` item signature doesn't match `trait` item signature
unimplemented!();
}
}
fn main() {}

View file

@ -1,18 +0,0 @@
error: `impl` item signature doesn't match `trait` item signature
--> $DIR/mismatched_trait_impl-2.rs:8:5
|
LL | fn deref(&self) -> &dyn Trait {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 Struct) -> &'1 (dyn Trait + '1)`
|
::: $SRC_DIR/core/src/ops/deref.rs:LL:COL
|
LL | fn deref(&self) -> &Self::Target;
| --------------------------------- expected `fn(&'1 Struct) -> &'1 (dyn Trait + 'static)`
|
= note: expected `fn(&'1 Struct) -> &'1 (dyn Trait + 'static)`
found `fn(&'1 Struct) -> &'1 (dyn Trait + '1)`
= help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait`
= help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output
error: aborting due to previous error

View file

@ -1,16 +0,0 @@
error: `impl` item signature doesn't match `trait` item signature
--> $DIR/mismatched_trait_impl.rs:9:5
|
LL | fn foo(&self, x: &'a u32, y: &u32) -> &'a u32;
| ---------------------------------------------- expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32`
...
LL | fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32`
|
= note: expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32`
found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32`
= help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait`
= help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output
error: aborting due to previous error

View file

@ -1,14 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
trait Get {
fn foo(&self, x: &'a u32, y: &u32) -> &'a u32;
}
impl Get for i32 {
fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 { //~ ERROR `impl` item signature doesn't match
x //~ ERROR lifetime mismatch
}
}
fn main() {}

View file

@ -1,27 +0,0 @@
error: `impl` item signature doesn't match `trait` item signature
--> $DIR/mismatched_trait_impl.rs:9:5
|
LL | fn foo(&self, x: &'a u32, y: &u32) -> &'a u32;
| ---------------------------------------------- expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32`
...
LL | fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32`
|
= note: expected `fn(&'1 i32, &'a u32, &'2 u32) -> &'a u32`
found `fn(&'1 i32, &'2 u32, &'3 u32) -> &'3 u32`
= help: the lifetime requirements from the `impl` do not correspond to the requirements in the `trait`
= help: verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output
error[E0623]: lifetime mismatch
--> $DIR/mismatched_trait_impl.rs:10:9
|
LL | fn foo(&self, x: &u32, y: &'a u32) -> &'a u32 {
| ---- -------
| |
| this parameter and the return type are declared with different lifetimes...
LL | x
| ^ ...but data from `x` is returned here
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0623`.

View file

@ -1,11 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
fn foo(x: &'a u32) -> &'a u32 { x }
fn main() {
let mut p = 3;
let r = foo(&p);
p += 1; //~ ERROR cannot assign to `p` because it is borrowed
println!("{}", r);
}

View file

@ -1,13 +0,0 @@
error[E0506]: cannot assign to `p` because it is borrowed
--> $DIR/mut_while_borrow.rs:9:5
|
LL | let r = foo(&p);
| -- borrow of `p` occurs here
LL | p += 1;
| ^^^^^^ assignment to borrowed `p` occurs here
LL | println!("{}", r);
| - borrow later used here
error: aborting due to previous error
For more information about this error, try `rustc --explain E0506`.

View file

@ -1,20 +0,0 @@
// Test that the `'a` from the impl doesn't
// prevent us from creating a `'a` parameter
// on the `blah` function.
//
// check-pass
#![feature(in_band_lifetimes)]
struct Foo<'a> {
x: &'a u32
}
impl Foo<'a> {
fn method(&self) {
fn blah(f: Foo<'a>) { }
}
}
fn main() { }

View file

@ -1,12 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
struct Foo {
x: &'test u32, //~ ERROR undeclared lifetime
}
enum Bar {
Baz(&'test u32), //~ ERROR undeclared lifetime
}
fn main() {}

View file

@ -1,19 +0,0 @@
error[E0261]: use of undeclared lifetime name `'test`
--> $DIR/no_in_band_in_struct.rs:5:9
|
LL | struct Foo {
| - help: consider introducing lifetime `'test` here: `<'test>`
LL | x: &'test u32,
| ^^^^^ undeclared lifetime
error[E0261]: use of undeclared lifetime name `'test`
--> $DIR/no_in_band_in_struct.rs:9:10
|
LL | enum Bar {
| - help: consider introducing lifetime `'test` here: `<'test>`
LL | Baz(&'test u32),
| ^^^^^ undeclared lifetime
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0261`.

View file

@ -1,13 +0,0 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
fn foo(x: &u32) {
let y: &'test u32 = x; //~ ERROR use of undeclared lifetime
}
fn foo2(x: &u32) {}
fn bar() {
let y: fn(&'test u32) = foo2; //~ ERROR use of undeclared lifetime
}
fn main() {}

View file

@ -1,27 +0,0 @@
error[E0261]: use of undeclared lifetime name `'test`
--> $DIR/no_introducing_in_band_in_locals.rs:5:13
|
LL | fn foo(x: &u32) {
| - help: consider introducing lifetime `'test` here: `<'test>`
LL | let y: &'test u32 = x;
| ^^^^^ undeclared lifetime
error[E0261]: use of undeclared lifetime name `'test`
--> $DIR/no_introducing_in_band_in_locals.rs:10:16
|
LL | let y: fn(&'test u32) = foo2;
| ^^^^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
help: consider introducing lifetime `'test` here
|
LL | fn bar<'test>() {
| +++++++
help: consider making the type lifetime-generic with a new `'test` lifetime
|
LL | let y: for<'test> fn(&'test u32) = foo2;
| ++++++++++
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0261`.

View file

@ -1,5 +1,4 @@
#![feature(generic_associated_types)]
#![allow(unused)]
trait Trait<'a> {
type Foo;

View file

@ -1,5 +1,5 @@
error[E0106]: missing lifetime specifier
--> $DIR/missing-lifetime-in-alias.rs:23:24
--> $DIR/missing-lifetime-in-alias.rs:22:24
|
LL | type B<'a> = <A<'a> as Trait>::Foo;
| ^^^^^ expected named lifetime parameter
@ -10,25 +10,25 @@ LL | type B<'a> = <A<'a> as Trait<'a>>::Foo;
| ~~~~~~~~~
error[E0106]: missing lifetime specifier
--> $DIR/missing-lifetime-in-alias.rs:27:28
--> $DIR/missing-lifetime-in-alias.rs:26:28
|
LL | type C<'a, 'b> = <A<'a> as Trait>::Bar;
| ^^^^^ expected named lifetime parameter
|
note: these named lifetimes are available to use
--> $DIR/missing-lifetime-in-alias.rs:27:8
--> $DIR/missing-lifetime-in-alias.rs:26:8
|
LL | type C<'a, 'b> = <A<'a> as Trait>::Bar;
| ^^ ^^
error[E0107]: missing generics for associated type `Trait::Bar`
--> $DIR/missing-lifetime-in-alias.rs:27:36
--> $DIR/missing-lifetime-in-alias.rs:26:36
|
LL | type C<'a, 'b> = <A<'a> as Trait>::Bar;
| ^^^ expected 1 lifetime argument
|
note: associated type defined here, with 1 lifetime parameter: `'b`
--> $DIR/missing-lifetime-in-alias.rs:7:10
--> $DIR/missing-lifetime-in-alias.rs:6:10
|
LL | type Bar<'b>
| ^^^ --

View file

@ -0,0 +1,7 @@
// check-pass
fn method<'a>(_i: &'a i32) {
fn inner<'a>(_j: &'a f32) {}
}
fn main() {}

View file

@ -1,9 +1,6 @@
#![allow(warnings)]
#![feature(in_band_lifetimes)]
struct Foo<T>(T);
impl Foo<&'s u8> {
impl<'s> Foo<&'s u8> {
fn bar<'s>(&self, x: &'s u8) {} //~ ERROR shadows a lifetime name
fn baz(x: for<'s> fn(&'s u32)) {} //~ ERROR shadows a lifetime name
}

View file

@ -1,16 +1,16 @@
error[E0496]: lifetime name `'s` shadows a lifetime name that is already in scope
--> $DIR/shadow.rs:7:12
--> $DIR/shadow.rs:4:12
|
LL | impl Foo<&'s u8> {
| -- first declared here
LL | impl<'s> Foo<&'s u8> {
| -- first declared here
LL | fn bar<'s>(&self, x: &'s u8) {}
| ^^ lifetime `'s` already in scope
error[E0496]: lifetime name `'s` shadows a lifetime name that is already in scope
--> $DIR/shadow.rs:8:19
--> $DIR/shadow.rs:5:19
|
LL | impl Foo<&'s u8> {
| -- first declared here
LL | impl<'s> Foo<&'s u8> {
| -- first declared here
LL | fn bar<'s>(&self, x: &'s u8) {}
LL | fn baz(x: for<'s> fn(&'s u32)) {}
| ^^ lifetime `'s` already in scope

View file

@ -5,8 +5,6 @@ LL | struct Test {
| - help: consider introducing lifetime `'b` here: `<'b>`
LL | a: &'b str,
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/undeclared-lifetime-used-in-debug-macro-issue-70152.rs:3:9
@ -15,8 +13,6 @@ LL | struct Test {
| - help: consider introducing lifetime `'b` here: `<'b>`
LL | a: &'b str,
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/undeclared-lifetime-used-in-debug-macro-issue-70152.rs:13:13
@ -24,7 +20,6 @@ error[E0261]: use of undeclared lifetime name `'b`
LL | fn foo(&'b self) {}
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b> T for Test {

View file

@ -5,8 +5,6 @@ LL | fn main() {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | 0.clone::<'a>();
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to previous error

View file

@ -1,5 +1,5 @@
error: lifetime may not live long enough
--> $DIR/issue-52742.rs:14:9
--> $DIR/issue-52742.rs:12:9
|
LL | fn take_bar(&mut self, b: Bar<'_>) {
| --------- -- let's call this `'1`

View file

@ -1,5 +1,3 @@
#![feature(in_band_lifetimes)]
struct Foo<'a, 'b> {
x: &'a u32,
y: &'b u32,

View file

@ -1,16 +1,16 @@
error[E0312]: lifetime of reference outlives lifetime of borrowed content...
--> $DIR/issue-52742.rs:14:18
--> $DIR/issue-52742.rs:12:18
|
LL | self.y = b.z
| ^^^
|
note: ...the reference is valid for the lifetime `'_` as defined here...
--> $DIR/issue-52742.rs:12:10
--> $DIR/issue-52742.rs:10:10
|
LL | impl Foo<'_, '_> {
| ^^
note: ...but the borrowed content is only valid for the anonymous lifetime defined here
--> $DIR/issue-52742.rs:13:31
--> $DIR/issue-52742.rs:11:31
|
LL | fn take_bar(&mut self, b: Bar<'_>) {
| ^^^^^^^

View file

@ -5,8 +5,6 @@ LL | enum No0 {
| - help: consider introducing lifetime `'foo` here: `<'foo>`
LL | X5(&'foo usize)
| ^^^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-in-enums.rs:17:9
@ -15,8 +13,6 @@ LL | enum No1 {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | X6(&'a usize)
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors

View file

@ -5,8 +5,6 @@ LL | struct StructDecl {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | a: &'a isize,
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-in-structs.rs:11:9
@ -16,8 +14,6 @@ LL | struct StructDecl {
LL | a: &'a isize,
LL | b: &'a isize,
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors

View file

@ -5,8 +5,6 @@ LL | enum E {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | E1(&'a isize)
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:31:13
@ -15,8 +13,6 @@ LL | struct S {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | f: &'a isize
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/regions-name-undeclared.rs:16:24
@ -24,7 +20,6 @@ error[E0261]: use of undeclared lifetime name `'b`
LL | fn m4(&self, arg: &'b isize) { }
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
@ -40,7 +35,6 @@ error[E0261]: use of undeclared lifetime name `'b`
LL | fn m5(&'b self) { }
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
@ -56,7 +50,6 @@ error[E0261]: use of undeclared lifetime name `'b`
LL | fn m6(&self, arg: Foo<'b>) { }
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | impl<'b, 'a> Foo<'a> {
@ -73,8 +66,6 @@ LL | type X = Option<&'a isize>;
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:33:14
@ -83,8 +74,6 @@ LL | fn f(a: &'a isize) { }
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:41:17
@ -93,8 +82,6 @@ LL | fn fn_types(a: &'a isize,
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/regions-name-undeclared.rs:43:36
@ -103,7 +90,6 @@ LL | ... &'b isize,
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | fn fn_types<'b>(a: &'a isize,
@ -120,7 +106,6 @@ LL | ... &'b isize)>,
| ^^ undeclared lifetime
|
= note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'b` here
|
LL | fn fn_types<'b>(a: &'a isize,
@ -138,8 +123,6 @@ LL | fn fn_types(a: &'a isize,
...
LL | c: &'a isize)
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-name-undeclared.rs:53:31
@ -147,7 +130,6 @@ error[E0261]: use of undeclared lifetime name `'a`
LL | async fn buggy(&self) -> &'a str {
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
help: consider introducing lifetime `'a` here
|
LL | impl<'a> Bug {

View file

@ -11,8 +11,6 @@ LL | enum EnumDecl {
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | Foo(&'a isize),
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-undeclared.rs:5:10
@ -22,8 +20,6 @@ LL | enum EnumDecl {
LL | Foo(&'a isize),
LL | Bar(&'a isize),
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-undeclared.rs:8:15
@ -32,8 +28,6 @@ LL | fn fnDecl(x: &'a isize,
| - ^^ undeclared lifetime
| |
| help: consider introducing lifetime `'a` here: `<'a>`
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'a`
--> $DIR/regions-undeclared.rs:9:15
@ -42,8 +36,6 @@ LL | fn fnDecl(x: &'a isize,
| - help: consider introducing lifetime `'a` here: `<'a>`
LL | y: &'a isize)
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 5 previous errors

View file

@ -1,18 +0,0 @@
// run-rustfix
#![feature(in_band_lifetimes)]
#![deny(single_use_lifetimes)]
#![allow(dead_code)]
#![allow(unused_variables)]
// Test that we DO warn when lifetime name is used only
// once in a fn argument, even with in band lifetimes.
fn a(x: &u32, y: &u32) {
//~^ ERROR `'a` only used once
//~| ERROR `'b` only used once
//~| HELP elide the single-use lifetime
//~| HELP elide the single-use lifetime
}
fn main() { }

View file

@ -1,18 +0,0 @@
// run-rustfix
#![feature(in_band_lifetimes)]
#![deny(single_use_lifetimes)]
#![allow(dead_code)]
#![allow(unused_variables)]
// Test that we DO warn when lifetime name is used only
// once in a fn argument, even with in band lifetimes.
fn a(x: &'a u32, y: &'b u32) {
//~^ ERROR `'a` only used once
//~| ERROR `'b` only used once
//~| HELP elide the single-use lifetime
//~| HELP elide the single-use lifetime
}
fn main() { }

View file

@ -1,26 +0,0 @@
error: lifetime parameter `'a` only used once
--> $DIR/one-use-in-fn-argument-in-band.rs:11:10
|
LL | fn a(x: &'a u32, y: &'b u32) {
| ^^-
| |
| this lifetime is only used here
| help: elide the single-use lifetime
|
note: the lint level is defined here
--> $DIR/one-use-in-fn-argument-in-band.rs:4:9
|
LL | #![deny(single_use_lifetimes)]
| ^^^^^^^^^^^^^^^^^^^^
error: lifetime parameter `'b` only used once
--> $DIR/one-use-in-fn-argument-in-band.rs:11:22
|
LL | fn a(x: &'a u32, y: &'b u32) {
| ^^-
| |
| this lifetime is only used here
| help: elide the single-use lifetime
error: aborting due to 2 previous errors

View file

@ -6,8 +6,6 @@ LL | fn f() where
LL | for<'a> dyn Trait1<'a>: Trait1<'a>, // OK
LL | (dyn for<'a> Trait1<'a>): Trait1<'a>,
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error[E0261]: use of undeclared lifetime name `'b`
--> $DIR/where-lifetime-resolution.rs:8:52
@ -17,8 +15,6 @@ LL | fn f() where
...
LL | for<'a> dyn for<'b> Trait2<'a, 'b>: Trait2<'a, 'b>,
| ^^ undeclared lifetime
|
= help: if you want to experiment with in-band lifetime bindings, add `#![feature(in_band_lifetimes)]` to the crate attributes
error: aborting due to 2 previous errors