dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #124682 - estebank:issue-40990, r=pnkfelix 

Suggest setting lifetime in borrowck error involving types with elided lifetimes

```
error: lifetime may not live long enough
  --> $DIR/ex3-both-anon-regions-both-are-structs-2.rs:7:5
   |
LL | fn foo(mut x: Ref, y: Ref) {
   |        -----       - has type `Ref<'_, '1>`
   |        |
   |        has type `Ref<'_, '2>`
LL |     x.b = y.b;
   |     ^^^^^^^^^ assignment requires that `'1` must outlive `'2`
   |
help: consider introducing a named lifetime parameter
   |
LL | fn foo<'a>(mut x: Ref<'a, 'a>, y: Ref<'a, 'a>) {
   |       ++++           ++++++++        ++++++++
```

As can be seen above, it currently doesn't try to compare the `ty::Ty` lifetimes that diverged vs the `hir::Ty` to correctly suggest the following

```
help: consider introducing a named lifetime parameter
   |
LL | fn foo<'a>(mut x: Ref<'_, 'a>, y: Ref<'_, 'a>) {
   |       ++++           ++++++++        ++++++++
```

but I believe this to still be an improvement over the status quo.

Fix #40990.
This commit is contained in:
Matthias Krüger 2024-05-20 18:13:46 +02:00 committed by GitHub
parent 75cb5c51cd cf5702ee91
commit 29c603c1fa
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
42 changed files with 697 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
compiler/rustc_infer/messages.ftl
View File

@ -164,7 +164,10 @@ infer_label_bad = {$bad_kind ->
infer_lf_bound_not_satisfied = lifetime bound not satisfied
infer_lifetime_mismatch = lifetime mismatch
infer_lifetime_param_suggestion = consider introducing a named lifetime parameter{$is_impl ->
infer_lifetime_param_suggestion = consider {$is_reuse ->
[true] reusing
*[false] introducing
} a named lifetime parameter{$is_impl ->
[true] {" "}and update trait if needed
*[false] {""}
}

159
compiler/rustc_infer/src/errors/mod.rs
View File

@ -1,9 +1,11 @@
use hir::GenericParamKind;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{
codes::*, Applicability, Diag, DiagMessage, DiagStyledString, EmissionGuarantee, IntoDiagArg,
MultiSpan, SubdiagMessageOp, Subdiagnostic,
};
use rustc_hir as hir;
use rustc_hir::intravisit::{walk_ty, Visitor};
use rustc_hir::FnRetTy;
use rustc_macros::{Diagnostic, Subdiagnostic};
use rustc_middle::ty::print::TraitRefPrintOnlyTraitPath;
@ -355,31 +357,33 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
_f: &F,
) {
let mut mk_suggestion = || {
let (
hir::Ty { kind: hir::TyKind::Ref(lifetime_sub, _), .. },
hir::Ty { kind: hir::TyKind::Ref(lifetime_sup, _), .. },
) = (self.ty_sub, self.ty_sup)
else {
return false;
};
if !lifetime_sub.is_anonymous() || !lifetime_sup.is_anonymous() {
return false;
};
let Some(anon_reg) = self.tcx.is_suitable_region(self.sub) else {
return false;
};
let node = self.tcx.hir_node_by_def_id(anon_reg.def_id);
let is_impl = matches!(&node, hir::Node::ImplItem(_));
let generics = match node {
let (generics, parent_generics) = match node {
hir::Node::Item(&hir::Item {
kind: hir::ItemKind::Fn(_, ref generics, ..),
..
})
| hir::Node::TraitItem(&hir::TraitItem { ref generics, .. })
| hir::Node::ImplItem(&hir::ImplItem { ref generics, .. }) => generics,
| hir::Node::ImplItem(&hir::ImplItem { ref generics, .. }) => (
generics,
match self.tcx.parent_hir_node(self.tcx.local_def_id_to_hir_id(anon_reg.def_id))
{
hir::Node::Item(hir::Item {
kind: hir::ItemKind::Trait(_, _, ref generics, ..),
..
})
| hir::Node::Item(hir::Item {
kind: hir::ItemKind::Impl(hir::Impl { ref generics, .. }),
..
}) => Some(generics),
_ => None,
},
),
_ => return false,
};
@ -390,24 +394,112 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
.map(|p| p.name.ident().name)
.find(|i| *i != kw::UnderscoreLifetime);
let introduce_new = suggestion_param_name.is_none();
let mut default = "'a".to_string();
if let Some(parent_generics) = parent_generics {
let used: FxHashSet<_> = parent_generics
.params
.iter()
.filter(|p| matches!(p.kind, GenericParamKind::Lifetime { .. }))
.map(|p| p.name.ident().name)
.filter(|i| *i != kw::UnderscoreLifetime)
.map(|l| l.to_string())
.collect();
if let Some(lt) =
('a'..='z').map(|it| format!("'{it}")).find(|it| !used.contains(it))
{
// We want a lifetime that *isn't* present in the `trait` or `impl` that assoc
// `fn` belongs to. We could suggest reusing one of their lifetimes, but it is
// likely to be an over-constraining lifetime requirement, so we always add a
// lifetime to the `fn`.
default = lt;
}
}
let suggestion_param_name =
suggestion_param_name.map(|n| n.to_string()).unwrap_or_else(|| "'a".to_owned());
suggestion_param_name.map(|n| n.to_string()).unwrap_or_else(|| default);
debug!(?lifetime_sup.ident.span);
debug!(?lifetime_sub.ident.span);
let make_suggestion = |ident: Ident| {
let sugg = if ident.name == kw::Empty {
format!("{suggestion_param_name}, ")
} else if ident.name == kw::UnderscoreLifetime && ident.span.is_empty() {
format!("{suggestion_param_name} ")
} else {
suggestion_param_name.clone()
};
(ident.span, sugg)
struct ImplicitLifetimeFinder {
suggestions: Vec<(Span, String)>,
suggestion_param_name: String,
}
impl<'v> Visitor<'v> for ImplicitLifetimeFinder {
fn visit_ty(&mut self, ty: &'v hir::Ty<'v>) {
let make_suggestion = |ident: Ident| {
if ident.name == kw::Empty && ident.span.is_empty() {
format!("{}, ", self.suggestion_param_name)
} else if ident.name == kw::UnderscoreLifetime && ident.span.is_empty() {
format!("{} ", self.suggestion_param_name)
} else {
self.suggestion_param_name.clone()
}
};
match ty.kind {
hir::TyKind::Path(hir::QPath::Resolved(_, path)) => {
for segment in path.segments {
if let Some(args) = segment.args {
if args.args.iter().all(|arg| {
matches!(
arg,
hir::GenericArg::Lifetime(lifetime)
if lifetime.ident.name == kw::Empty
)
}) {
self.suggestions.push((
segment.ident.span.shrink_to_hi(),
format!(
"<{}>",
args.args
.iter()
.map(|_| self.suggestion_param_name.clone())
.collect::<Vec<_>>()
.join(", ")
),
));
} else {
for arg in args.args {
if let hir::GenericArg::Lifetime(lifetime) = arg
&& lifetime.is_anonymous()
{
self.suggestions.push((
lifetime.ident.span,
make_suggestion(lifetime.ident),
));
}
}
}
}
}
}
hir::TyKind::Ref(lifetime, ..) if lifetime.is_anonymous() => {
self.suggestions
.push((lifetime.ident.span, make_suggestion(lifetime.ident)));
}
_ => {}
}
walk_ty(self, ty);
}
}
let mut visitor = ImplicitLifetimeFinder {
suggestions: vec![],
suggestion_param_name: suggestion_param_name.clone(),
};
let mut suggestions =
vec![make_suggestion(lifetime_sub.ident), make_suggestion(lifetime_sup.ident)];
if let Some(fn_decl) = node.fn_decl()
&& let hir::FnRetTy::Return(ty) = fn_decl.output
{
visitor.visit_ty(ty);
}
if visitor.suggestions.is_empty() {
// Do not suggest constraining the `&self` param, but rather the return type.
// If that is wrong (because it is not sufficient), a follow up error will tell the
// user to fix it. This way we lower the chances of *over* constraining, but still
// get the cake of "correctly" contrained in two steps.
visitor.visit_ty(self.ty_sup);
}
visitor.visit_ty(self.ty_sub);
if visitor.suggestions.is_empty() {
return false;
}
if introduce_new {
let new_param_suggestion = if let Some(first) =
generics.params.iter().find(|p| !p.name.ident().span.is_empty())
@ -417,15 +509,16 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
(generics.span, format!("<{suggestion_param_name}>"))
};
suggestions.push(new_param_suggestion);
visitor.suggestions.push(new_param_suggestion);
}
diag.multipart_suggestion(
diag.multipart_suggestion_verbose(
fluent::infer_lifetime_param_suggestion,
suggestions,
visitor.suggestions,
Applicability::MaybeIncorrect,
);
diag.arg("is_impl", is_impl);
diag.arg("is_reuse", !introduce_new);
true
};
if mk_suggestion() && self.add_note {

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

@ -29,8 +29,8 @@ LL | Some(entry) => Ok(entry),
|
help: consider introducing a named lifetime parameter
|
LL | fn attemptTraverse<'a>(&'a self, room: &'a Room, directionStr: &str) -> Result<&Room, &str> {
| ++++ ++ ++
LL | fn attemptTraverse<'a>(&self, room: &'a Room, directionStr: &str) -> Result<&'a Room, &'a str> {
| ++++ ++ ++ ++
error: aborting due to 2 previous errors

2
tests/ui/lifetimes/issue-90170-elision-mismatch.stderr
View File

@ -35,7 +35,7 @@ LL | pub fn foo3<'a>(_other: &'a [u8], x: &mut Vec<&u8>, y: &u8) { x.push(y); }
| | let's call the lifetime of this reference `'1`
| let's call the lifetime of this reference `'2`
|
help: consider introducing a named lifetime parameter
help: consider reusing a named lifetime parameter
|
LL | pub fn foo3<'a>(_other: &'a [u8], x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); }
| ++ ++

5
tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-if-else-using-impl.stderr
View File

@ -8,6 +8,11 @@ LL | fn foo<'a>(x: &i32, y: &'a i32) -> &'a i32 {
LL |
LL | if x > y { x } else { y }
| ^ associated function was supposed to return data with lifetime `'a` but it is returning data with lifetime `'1`
|
help: consider reusing a named lifetime parameter and update trait if needed
|
LL | fn foo<'a>(x: &'a i32, y: &'a i32) -> &'a i32 {
| ++
error: aborting due to 1 previous error

14
tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.fixed Normal file
View File

@ -0,0 +1,14 @@
//@ run-rustfix
#![allow(dead_code)]
struct Foo {
field: i32,
}
impl Foo {
fn foo<'a>(&self, x: &'a i32) -> &'a i32 {
x
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

17
tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.rs
View File

@ -1,15 +1,14 @@
//@ run-rustfix
#![allow(dead_code)]
struct Foo {
field: i32
field: i32,
}
impl Foo {
fn foo<'a>(&self, x: &'a i32) -> &i32 {
x
//~^ ERROR lifetime may not live long enough
}
fn foo<'a>(&self, x: &'a i32) -> &i32 {
x
//~^ ERROR lifetime may not live long enough
}
}
fn main() { }
fn main() {}

20
tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.stderr
View File

@ -1,13 +1,17 @@
error: lifetime may not live long enough
--> $DIR/ex1-return-one-existing-name-return-type-is-anon.rs:8:5
--> $DIR/ex1-return-one-existing-name-return-type-is-anon.rs:9:9
|
LL | fn foo<'a>(&self, x: &'a i32) -> &i32 {
| -- - let's call the lifetime of this reference `'1`
| |
| lifetime `'a` defined here
LL |
LL | x
| ^ method was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`
LL | fn foo<'a>(&self, x: &'a i32) -> &i32 {
| -- - let's call the lifetime of this reference `'1`
| |
| lifetime `'a` defined here
LL | x
| ^ method was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`
|
help: consider reusing a named lifetime parameter and update trait if needed
|
LL | fn foo<'a>(&self, x: &'a i32) -> &'a i32 {
| ++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-self-is-anon.stderr
View File

@ -8,6 +8,11 @@ LL | fn foo<'a>(&self, x: &'a Foo) -> &'a Foo {
LL |
LL | if true { x } else { self }
| ^^^^ method was supposed to return data with lifetime `'a` but it is returning data with lifetime `'1`
|
help: consider reusing a named lifetime parameter and update trait if needed
|
LL | fn foo<'a>(&'a self, x: &'a Foo) -> &'a Foo {
| ++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex2b-push-no-existing-names.stderr
View File

@ -7,6 +7,11 @@ LL | fn foo(x: &mut Vec<Ref<i32>>, y: Ref<i32>) {
| has type `&mut Vec<Ref<'2, i32>>`
LL | x.push(y);
| ^^^^^^^^^ argument requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(x: &mut Vec<Ref<'a, i32>>, y: Ref<'a, i32>) {
| ++++ +++ +++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-2.stderr
View File

@ -7,6 +7,11 @@ LL | fn foo(mut x: Ref, y: Ref) {
| has type `Ref<'_, '2>`
LL | x.b = y.b;
| ^^^^^^^^^ assignment requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(mut x: Ref<'a, 'a>, y: Ref<'a, 'a>) {
| ++++ ++++++++ ++++++++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs-3.stderr
View File

@ -8,6 +8,11 @@ LL | fn foo(mut x: Ref) {
| has type `Ref<'2, '_>`
LL | x.a = x.b;
| ^^^^^^^^^ assignment requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(mut x: Ref<'a, 'a>) {
| ++++ ++++++++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-both-are-structs.stderr
View File

@ -7,6 +7,11 @@ LL | fn foo(mut x: Vec<Ref>, y: Ref) {
| has type `Vec<Ref<'2>>`
LL | x.push(y);
| ^^^^^^^^^ argument requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(mut x: Vec<Ref<'a>>, y: Ref<'a>) {
| ++++ ++++ ++++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-2.stderr
View File

@ -7,6 +7,11 @@ LL | fn foo(mut x: Ref, y: &u32) {
| has type `Ref<'_, '1>`
LL | y = x.b;
| ^^^^^^^ assignment requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(mut x: Ref<'a, 'a>, y: &'a u32) {
| ++++ ++++++++ ++
error[E0384]: cannot assign to immutable argument `y`
--> $DIR/ex3-both-anon-regions-one-is-struct-2.rs:4:5

5
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-3.stderr
View File

@ -7,6 +7,11 @@ LL | fn foo(mut y: Ref, x: &u32) {
| has type `Ref<'_, '2>`
LL | y.b = x;
| ^^^^^^^ assignment requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(mut y: Ref<'a, 'a>, x: &'a u32) {
| ++++ ++++++++ ++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct-4.stderr
View File

@ -7,6 +7,11 @@ LL | fn foo(mut y: Ref, x: &u32) {
| has type `Ref<'_, '2>`
LL | y.b = x;
| ^^^^^^^ assignment requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(mut y: Ref<'a, 'a>, x: &'a u32) {
| ++++ ++++++++ ++
error: aborting due to 1 previous error

5
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-one-is-struct.stderr
View File

@ -7,6 +7,11 @@ LL | fn foo(mut x: Ref, y: &u32) {
| has type `Ref<'_, '2>`
LL | x.b = y;
| ^^^^^^^ assignment requires that `'1` must outlive `'2`
|
help: consider introducing a named lifetime parameter
|
LL | fn foo<'a>(mut x: Ref<'a, 'a>, y: &'a u32) {
| ++++ ++++++++ ++
error: aborting due to 1 previous error

14
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.fixed Normal file
View File

@ -0,0 +1,14 @@
//@ run-rustfix
#![allow(dead_code)]
struct Foo {
field: i32,
}
impl Foo {
fn foo<'a>(&self, x: &'a i32) -> &'a i32 {
x
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

14
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.rs
View File

@ -1,12 +1,14 @@
//@ run-rustfix
#![allow(dead_code)]
struct Foo {
field: i32
field: i32,
}
impl Foo {
fn foo<'a>(&self, x: &i32) -> &i32 {
x
//~^ ERROR lifetime may not live long enough
}
fn foo<'a>(&self, x: &i32) -> &i32 {
x
//~^ ERROR lifetime may not live long enough
}
}
fn main() { }
fn main() {}

20
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.stderr
View File

@ -1,17 +1,17 @@
error: lifetime may not live long enough
--> $DIR/ex3-both-anon-regions-return-type-is-anon.rs:7:5
--> $DIR/ex3-both-anon-regions-return-type-is-anon.rs:9:9
|
LL | fn foo<'a>(&self, x: &i32) -> &i32 {
| - - let's call the lifetime of this reference `'1`
| |
| let's call the lifetime of this reference `'2`
LL | x
| ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
LL | fn foo<'a>(&self, x: &i32) -> &i32 {
| - - let's call the lifetime of this reference `'1`
| |
| let's call the lifetime of this reference `'2`
LL | x
| ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
|
help: consider introducing a named lifetime parameter and update trait if needed
help: consider reusing a named lifetime parameter and update trait if needed
|
LL | fn foo<'a>(&'a self, x: &'a i32) -> &i32 {
| ++ ++
LL | fn foo<'a>(&self, x: &'a i32) -> &'a i32 {
| ++ ++
error: aborting due to 1 previous error

6
tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-self-is-anon.stderr
View File

@ -8,10 +8,10 @@ LL | fn foo<'a>(&self, x: &Foo) -> &Foo {
LL | if true { x } else { self }
| ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
|
help: consider introducing a named lifetime parameter and update trait if needed
help: consider reusing a named lifetime parameter and update trait if needed
|
LL | fn foo<'a>(&'a self, x: &'a Foo) -> &Foo {
| ++ ++
LL | fn foo<'a>(&self, x: &'a Foo) -> &'a Foo {
| ++ ++
error: aborting due to 1 previous error

5
tests/ui/self/arbitrary_self_types_pin_lifetime_mismatch-async.stderr
View File

@ -34,6 +34,11 @@ LL | async fn bar<'a>(self: Alias<&Self>, arg: &'a ()) -> &() { arg }
| | |
| | let's call the lifetime of this reference `'1`
| lifetime `'a` defined here
|
help: consider reusing a named lifetime parameter and update trait if needed
|
LL | async fn bar<'a>(self: Alias<&'a Self>, arg: &'a ()) -> &() { arg }
| ++
error: aborting due to 3 previous errors

18
tests/ui/self/arbitrary_self_types_pin_lifetime_mismatch.rs
View File

@ -3,17 +3,23 @@ use std::pin::Pin;
struct Foo;
impl Foo {
fn a(self: Pin<&Foo>, f: &Foo) -> &Foo { f }
//~^ lifetime may not live long enough
fn a(self: Pin<&Foo>, f: &Foo) -> &Foo {
f //~ ERROR lifetime may not live long enough
}
fn c(self: Pin<&Self>, f: &Foo, g: &Foo) -> (Pin<&Foo>, &Foo) { (self, f) }
//~^ lifetime may not live long enough
// For this suggestion to be right, we'd need to also suggest `self: Pin<&'a Self>`, which we
// don't, but we provide a follow up suggestion to do so, so I condider that good at least for
// now.
fn c(self: Pin<&Self>, f: &Foo, g: &Foo) -> (Pin<&Foo>, &Foo) {
(self, f) //~ ERROR lifetime may not live long enough
}
}
type Alias<T> = Pin<T>;
impl Foo {
fn bar<'a>(self: Alias<&Self>, arg: &'a ()) -> &() { arg }
//~^ lifetime may not live long enough
fn bar<'a>(self: Alias<&Self>, arg: &'a ()) -> &() {
arg //~ ERROR lifetime may not live long enough
}
}
fn main() {}

43
tests/ui/self/arbitrary_self_types_pin_lifetime_mismatch.stderr
View File

@ -1,38 +1,47 @@
error: lifetime may not live long enough
--> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:6:46
--> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:7:9
|
LL | fn a(self: Pin<&Foo>, f: &Foo) -> &Foo { f }
| - - ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
| | |
| | let's call the lifetime of this reference `'1`
LL | fn a(self: Pin<&Foo>, f: &Foo) -> &Foo {
| - - let's call the lifetime of this reference `'1`
| |
| let's call the lifetime of this reference `'2`
LL | f
| ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn a<'a>(self: Pin<&'a Foo>, f: &'a Foo) -> &Foo { f }
| ++++ ++ ++
LL | fn a<'a>(self: Pin<&Foo>, f: &'a Foo) -> &'a Foo {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:9:69
--> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:14:9
|
LL | fn c(self: Pin<&Self>, f: &Foo, g: &Foo) -> (Pin<&Foo>, &Foo) { (self, f) }
| - - ^^^^^^^^^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
| | |
| | let's call the lifetime of this reference `'1`
LL | fn c(self: Pin<&Self>, f: &Foo, g: &Foo) -> (Pin<&Foo>, &Foo) {
| - - let's call the lifetime of this reference `'1`
| |
| let's call the lifetime of this reference `'2`
LL | (self, f)
| ^^^^^^^^^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn c<'a>(self: Pin<&'a Self>, f: &'a Foo, g: &Foo) -> (Pin<&Foo>, &Foo) { (self, f) }
| ++++ ++ ++
LL | fn c<'a>(self: Pin<&Self>, f: &'a Foo, g: &Foo) -> (Pin<&'a Foo>, &'a Foo) {
| ++++ ++ ++ ++
error: lifetime may not live long enough
--> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:15:58
--> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:21:9
|
LL | fn bar<'a>(self: Alias<&Self>, arg: &'a ()) -> &() { arg }
| -- ---- has type `Pin<&'1 Foo>` ^^^ method was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`
LL | fn bar<'a>(self: Alias<&Self>, arg: &'a ()) -> &() {
| -- ---- has type `Pin<&'1 Foo>`
| |
| lifetime `'a` defined here
LL | arg
| ^^^ method was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`
|
help: consider reusing a named lifetime parameter and update trait if needed
|
LL | fn bar<'a>(self: Alias<&Self>, arg: &'a ()) -> &'a () {
| ++
error: aborting due to 3 previous errors

47
tests/ui/self/elision/lt-ref-self-async.fixed Normal file
View File

@ -0,0 +1,47 @@
//@ edition:2018
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct<'a> {
data: &'a u32,
}
impl<'a> Struct<'a> {
// Test using `&self` sugar:
async fn ref_self<'b>(&'b self, f: &'b u32) -> &u32 {
f
//~^ ERROR lifetime may not live long enough
}
// Test using `&Self` explicitly:
async fn ref_Self<'b>(self: &'b Self, f: &'b u32) -> &u32 {
f
//~^ ERROR lifetime may not live long enough
}
async fn box_ref_Self<'b>(self: Box<&'b Self>, f: &'b u32) -> &u32 {
f
//~^ ERROR lifetime may not live long enough
}
async fn pin_ref_Self<'b>(self: Pin<&'b Self>, f: &'b u32) -> &u32 {
f
//~^ ERROR lifetime may not live long enough
}
async fn box_box_ref_Self<'b>(self: Box<Box<&'b Self>>, f: &'b u32) -> &u32 {
f
//~^ ERROR lifetime may not live long enough
}
async fn box_pin_Self<'b>(self: Box<Pin<&'b Self>>, f: &'b u32) -> &u32 {
f
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

10
tests/ui/self/elision/lt-ref-self-async.rs
View File

@ -1,10 +1,12 @@
//@ edition:2018
#![allow(non_snake_case)]
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct<'a> { data: &'a u32 }
struct Struct<'a> {
data: &'a u32,
}
impl<'a> Struct<'a> {
// Test using `&self` sugar:
@ -42,4 +44,4 @@ impl<'a> Struct<'a> {
}
}
fn main() { }
fn main() {}

24
tests/ui/self/elision/lt-ref-self-async.stderr
View File

@ -1,5 +1,5 @@
error: lifetime may not live long enough
--> $DIR/lt-ref-self-async.rs:13:9
--> $DIR/lt-ref-self-async.rs:15:9
|
LL | async fn ref_self(&self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -10,11 +10,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | async fn ref_self<'a>(&'a self, f: &'a u32) -> &u32 {
LL | async fn ref_self<'b>(&'b self, f: &'b u32) -> &u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self-async.rs:20:9
--> $DIR/lt-ref-self-async.rs:22:9
|
LL | async fn ref_Self(self: &Self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -25,11 +25,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | async fn ref_Self<'a>(self: &'a Self, f: &'a u32) -> &u32 {
LL | async fn ref_Self<'b>(self: &'b Self, f: &'b u32) -> &u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self-async.rs:25:9
--> $DIR/lt-ref-self-async.rs:27:9
|
LL | async fn box_ref_Self(self: Box<&Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -40,11 +40,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | async fn box_ref_Self<'a>(self: Box<&'a Self>, f: &'a u32) -> &u32 {
LL | async fn box_ref_Self<'b>(self: Box<&'b Self>, f: &'b u32) -> &u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self-async.rs:30:9
--> $DIR/lt-ref-self-async.rs:32:9
|
LL | async fn pin_ref_Self(self: Pin<&Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -55,11 +55,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | async fn pin_ref_Self<'a>(self: Pin<&'a Self>, f: &'a u32) -> &u32 {
LL | async fn pin_ref_Self<'b>(self: Pin<&'b Self>, f: &'b u32) -> &u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self-async.rs:35:9
--> $DIR/lt-ref-self-async.rs:37:9
|
LL | async fn box_box_ref_Self(self: Box<Box<&Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -70,11 +70,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | async fn box_box_ref_Self<'a>(self: Box<Box<&'a Self>>, f: &'a u32) -> &u32 {
LL | async fn box_box_ref_Self<'b>(self: Box<Box<&'b Self>>, f: &'b u32) -> &u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self-async.rs:40:9
--> $DIR/lt-ref-self-async.rs:42:9
|
LL | async fn box_pin_Self(self: Box<Pin<&Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -85,7 +85,7 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | async fn box_pin_Self<'a>(self: Box<Pin<&'a Self>>, f: &'a u32) -> &u32 {
LL | async fn box_pin_Self<'b>(self: Box<Pin<&'b Self>>, f: &'b u32) -> &u32 {
| ++++ ++ ++
error: aborting due to 6 previous errors

46
tests/ui/self/elision/lt-ref-self.fixed Normal file
View File

@ -0,0 +1,46 @@
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct<'a> {
data: &'a u32,
}
impl<'a> Struct<'a> {
// Test using `&self` sugar:
fn ref_self<'b>(&self, f: &'b u32) -> &'b u32 {
f
//~^ ERROR lifetime may not live long enough
}
// Test using `&Self` explicitly:
fn ref_Self<'b>(self: &Self, f: &'b u32) -> &'b u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_ref_Self<'b>(self: Box<&Self>, f: &'b u32) -> &'b u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn pin_ref_Self<'b>(self: Pin<&Self>, f: &'b u32) -> &'b u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_box_ref_Self<'b>(self: Box<Box<&Self>>, f: &'b u32) -> &'b u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_pin_Self<'b>(self: Box<Pin<&Self>>, f: &'b u32) -> &'b u32 {
f
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

9
tests/ui/self/elision/lt-ref-self.rs
View File

@ -1,8 +1,11 @@
#![allow(non_snake_case)]
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct<'a> { data: &'a u32 }
struct Struct<'a> {
data: &'a u32,
}
impl<'a> Struct<'a> {
// Test using `&self` sugar:
@ -40,4 +43,4 @@ impl<'a> Struct<'a> {
}
}
fn main() { }
fn main() {}

36
tests/ui/self/elision/lt-ref-self.stderr
View File

@ -1,5 +1,5 @@
error: lifetime may not live long enough
--> $DIR/lt-ref-self.rs:11:9
--> $DIR/lt-ref-self.rs:14:9
|
LL | fn ref_self(&self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -10,11 +10,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_self<'a>(&'a self, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_self<'b>(&self, f: &'b u32) -> &'b u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self.rs:18:9
--> $DIR/lt-ref-self.rs:21:9
|
LL | fn ref_Self(self: &Self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -25,11 +25,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_Self<'a>(self: &'a Self, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_Self<'b>(self: &Self, f: &'b u32) -> &'b u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self.rs:23:9
--> $DIR/lt-ref-self.rs:26:9
|
LL | fn box_ref_Self(self: Box<&Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -40,11 +40,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_ref_Self<'a>(self: Box<&'a Self>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_ref_Self<'b>(self: Box<&Self>, f: &'b u32) -> &'b u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self.rs:28:9
--> $DIR/lt-ref-self.rs:31:9
|
LL | fn pin_ref_Self(self: Pin<&Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -55,11 +55,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn pin_ref_Self<'a>(self: Pin<&'a Self>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn pin_ref_Self<'b>(self: Pin<&Self>, f: &'b u32) -> &'b u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self.rs:33:9
--> $DIR/lt-ref-self.rs:36:9
|
LL | fn box_box_ref_Self(self: Box<Box<&Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -70,11 +70,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_box_ref_Self<'a>(self: Box<Box<&'a Self>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_box_ref_Self<'b>(self: Box<Box<&Self>>, f: &'b u32) -> &'b u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/lt-ref-self.rs:38:9
--> $DIR/lt-ref-self.rs:41:9
|
LL | fn box_pin_Self(self: Box<Pin<&Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -85,8 +85,8 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_pin_Self<'a>(self: Box<Pin<&'a Self>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_pin_Self<'b>(self: Box<Pin<&Self>>, f: &'b u32) -> &'b u32 {
| ++++ ++ ++
error: aborting due to 6 previous errors

44
tests/ui/self/elision/ref-mut-self.fixed Normal file
View File

@ -0,0 +1,44 @@
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct {}
impl Struct {
// Test using `&mut self` sugar:
fn ref_self<'a>(&mut self, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
// Test using `&mut Self` explicitly:
fn ref_Self<'a>(self: &mut Self, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_ref_Self<'a>(self: Box<&mut Self>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn pin_ref_Self<'a>(self: Pin<&mut Self>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_box_ref_Self<'a>(self: Box<Box<&mut Self>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_pin_ref_Self<'a>(self: Box<Pin<&mut Self>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

7
tests/ui/self/elision/ref-mut-self.rs
View File

@ -1,8 +1,9 @@
#![allow(non_snake_case)]
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct { }
struct Struct {}
impl Struct {
// Test using `&mut self` sugar:
@ -40,4 +41,4 @@ impl Struct {
}
}
fn main() { }
fn main() {}

36
tests/ui/self/elision/ref-mut-self.stderr
View File

@ -1,5 +1,5 @@
error: lifetime may not live long enough
--> $DIR/ref-mut-self.rs:11:9
--> $DIR/ref-mut-self.rs:12:9
|
LL | fn ref_self(&mut self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -10,11 +10,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_self<'a>(&'a mut self, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_self<'a>(&mut self, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-self.rs:18:9
--> $DIR/ref-mut-self.rs:19:9
|
LL | fn ref_Self(self: &mut Self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -25,11 +25,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_Self<'a>(self: &'a mut Self, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_Self<'a>(self: &mut Self, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-self.rs:23:9
--> $DIR/ref-mut-self.rs:24:9
|
LL | fn box_ref_Self(self: Box<&mut Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -40,11 +40,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_ref_Self<'a>(self: Box<&'a mut Self>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_ref_Self<'a>(self: Box<&mut Self>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-self.rs:28:9
--> $DIR/ref-mut-self.rs:29:9
|
LL | fn pin_ref_Self(self: Pin<&mut Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -55,11 +55,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn pin_ref_Self<'a>(self: Pin<&'a mut Self>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn pin_ref_Self<'a>(self: Pin<&mut Self>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-self.rs:33:9
--> $DIR/ref-mut-self.rs:34:9
|
LL | fn box_box_ref_Self(self: Box<Box<&mut Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -70,11 +70,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_box_ref_Self<'a>(self: Box<Box<&'a mut Self>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_box_ref_Self<'a>(self: Box<Box<&mut Self>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-self.rs:38:9
--> $DIR/ref-mut-self.rs:39:9
|
LL | fn box_pin_ref_Self(self: Box<Pin<&mut Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -85,8 +85,8 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_pin_ref_Self<'a>(self: Box<Pin<&'a mut Self>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_pin_ref_Self<'a>(self: Box<Pin<&mut Self>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: aborting due to 6 previous errors

37
tests/ui/self/elision/ref-mut-struct.fixed Normal file
View File

@ -0,0 +1,37 @@
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct {}
impl Struct {
// Test using `&mut Struct` explicitly:
fn ref_Struct<'a>(self: &mut Struct, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_ref_Struct<'a>(self: Box<&mut Struct>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn pin_ref_Struct<'a>(self: Pin<&mut Struct>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_box_ref_Struct<'a>(self: Box<Box<&mut Struct>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_pin_ref_Struct<'a>(self: Box<Pin<&mut Struct>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

7
tests/ui/self/elision/ref-mut-struct.rs
View File

@ -1,8 +1,9 @@
#![allow(non_snake_case)]
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct { }
struct Struct {}
impl Struct {
// Test using `&mut Struct` explicitly:
@ -33,4 +34,4 @@ impl Struct {
}
}
fn main() { }
fn main() {}

30
tests/ui/self/elision/ref-mut-struct.stderr
View File

@ -1,5 +1,5 @@
error: lifetime may not live long enough
--> $DIR/ref-mut-struct.rs:11:9
--> $DIR/ref-mut-struct.rs:12:9
|
LL | fn ref_Struct(self: &mut Struct, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -10,11 +10,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_Struct<'a>(self: &'a mut Struct, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_Struct<'a>(self: &mut Struct, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-struct.rs:16:9
--> $DIR/ref-mut-struct.rs:17:9
|
LL | fn box_ref_Struct(self: Box<&mut Struct>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -25,11 +25,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_ref_Struct<'a>(self: Box<&'a mut Struct>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_ref_Struct<'a>(self: Box<&mut Struct>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-struct.rs:21:9
--> $DIR/ref-mut-struct.rs:22:9
|
LL | fn pin_ref_Struct(self: Pin<&mut Struct>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -40,11 +40,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn pin_ref_Struct<'a>(self: Pin<&'a mut Struct>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn pin_ref_Struct<'a>(self: Pin<&mut Struct>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-struct.rs:26:9
--> $DIR/ref-mut-struct.rs:27:9
|
LL | fn box_box_ref_Struct(self: Box<Box<&mut Struct>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -55,11 +55,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_box_ref_Struct<'a>(self: Box<Box<&'a mut Struct>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_box_ref_Struct<'a>(self: Box<Box<&mut Struct>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-mut-struct.rs:31:9
--> $DIR/ref-mut-struct.rs:32:9
|
LL | fn box_pin_ref_Struct(self: Box<Pin<&mut Struct>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -70,8 +70,8 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_pin_ref_Struct<'a>(self: Box<Pin<&'a mut Struct>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_pin_ref_Struct<'a>(self: Box<Pin<&mut Struct>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: aborting due to 5 previous errors

61
tests/ui/self/elision/ref-self.fixed Normal file
View File

@ -0,0 +1,61 @@
//@ run-rustfix
#![feature(arbitrary_self_types)]
#![allow(non_snake_case, dead_code)]
use std::marker::PhantomData;
use std::ops::Deref;
use std::pin::Pin;
struct Struct {}
struct Wrap<T, P>(T, PhantomData<P>);
impl<T, P> Deref for Wrap<T, P> {
type Target = T;
fn deref(&self) -> &T {
&self.0
}
}
impl Struct {
// Test using `&self` sugar:
fn ref_self<'a>(&self, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
// Test using `&Self` explicitly:
fn ref_Self<'a>(self: &Self, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_ref_Self<'a>(self: Box<&Self>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn pin_ref_Self<'a>(self: Pin<&Self>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_box_ref_Self<'a>(self: Box<Box<&Self>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_pin_ref_Self<'a>(self: Box<Pin<&Self>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn wrap_ref_Self_Self<'a>(self: Wrap<&Self, Self>, f: &'a u8) -> &'a u8 {
f
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

11
tests/ui/self/elision/ref-self.rs
View File

@ -1,17 +1,20 @@
//@ run-rustfix
#![feature(arbitrary_self_types)]
#![allow(non_snake_case)]
#![allow(non_snake_case, dead_code)]
use std::marker::PhantomData;
use std::ops::Deref;
use std::pin::Pin;
struct Struct { }
struct Struct {}
struct Wrap<T, P>(T, PhantomData<P>);
impl<T, P> Deref for Wrap<T, P> {
type Target = T;
fn deref(&self) -> &T { &self.0 }
fn deref(&self) -> &T {
&self.0
}
}
impl Struct {
@ -55,4 +58,4 @@ impl Struct {
}
}
fn main() { }
fn main() {}

42
tests/ui/self/elision/ref-self.stderr
View File

@ -1,5 +1,5 @@
error: lifetime may not live long enough
--> $DIR/ref-self.rs:21:9
--> $DIR/ref-self.rs:24:9
|
LL | fn ref_self(&self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -10,11 +10,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_self<'a>(&'a self, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_self<'a>(&self, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-self.rs:28:9
--> $DIR/ref-self.rs:31:9
|
LL | fn ref_Self(self: &Self, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -25,11 +25,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_Self<'a>(self: &'a Self, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_Self<'a>(self: &Self, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-self.rs:33:9
--> $DIR/ref-self.rs:36:9
|
LL | fn box_ref_Self(self: Box<&Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -40,11 +40,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_ref_Self<'a>(self: Box<&'a Self>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_ref_Self<'a>(self: Box<&Self>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-self.rs:38:9
--> $DIR/ref-self.rs:41:9
|
LL | fn pin_ref_Self(self: Pin<&Self>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -55,11 +55,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn pin_ref_Self<'a>(self: Pin<&'a Self>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn pin_ref_Self<'a>(self: Pin<&Self>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-self.rs:43:9
--> $DIR/ref-self.rs:46:9
|
LL | fn box_box_ref_Self(self: Box<Box<&Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -70,11 +70,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_box_ref_Self<'a>(self: Box<Box<&'a Self>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_box_ref_Self<'a>(self: Box<Box<&Self>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-self.rs:48:9
--> $DIR/ref-self.rs:51:9
|
LL | fn box_pin_ref_Self(self: Box<Pin<&Self>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -85,11 +85,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_pin_ref_Self<'a>(self: Box<Pin<&'a Self>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_pin_ref_Self<'a>(self: Box<Pin<&Self>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-self.rs:53:9
--> $DIR/ref-self.rs:56:9
|
LL | fn wrap_ref_Self_Self(self: Wrap<&Self, Self>, f: &u8) -> &u8 {
| - - let's call the lifetime of this reference `'1`
@ -100,8 +100,8 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn wrap_ref_Self_Self<'a>(self: Wrap<&'a Self, Self>, f: &'a u8) -> &u8 {
| ++++ ++ ++
LL | fn wrap_ref_Self_Self<'a>(self: Wrap<&Self, Self>, f: &'a u8) -> &'a u8 {
| ++++ ++ ++
error: aborting due to 7 previous errors

37
tests/ui/self/elision/ref-struct.fixed Normal file
View File

@ -0,0 +1,37 @@
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct {}
impl Struct {
// Test using `&Struct` explicitly:
fn ref_Struct<'a>(self: &Struct, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_ref_Struct<'a>(self: Box<&Struct>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn pin_ref_Struct<'a>(self: Pin<&Struct>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_box_ref_Struct<'a>(self: Box<Box<&Struct>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
fn box_pin_Struct<'a>(self: Box<Pin<&Struct>>, f: &'a u32) -> &'a u32 {
f
//~^ ERROR lifetime may not live long enough
}
}
fn main() {}

7
tests/ui/self/elision/ref-struct.rs
View File

@ -1,8 +1,9 @@
#![allow(non_snake_case)]
//@ run-rustfix
#![allow(non_snake_case, dead_code)]
use std::pin::Pin;
struct Struct { }
struct Struct {}
impl Struct {
// Test using `&Struct` explicitly:
@ -33,4 +34,4 @@ impl Struct {
}
}
fn main() { }
fn main() {}

30
tests/ui/self/elision/ref-struct.stderr
View File

@ -1,5 +1,5 @@
error: lifetime may not live long enough
--> $DIR/ref-struct.rs:11:9
--> $DIR/ref-struct.rs:12:9
|
LL | fn ref_Struct(self: &Struct, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -10,11 +10,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn ref_Struct<'a>(self: &'a Struct, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn ref_Struct<'a>(self: &Struct, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-struct.rs:16:9
--> $DIR/ref-struct.rs:17:9
|
LL | fn box_ref_Struct(self: Box<&Struct>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -25,11 +25,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_ref_Struct<'a>(self: Box<&'a Struct>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_ref_Struct<'a>(self: Box<&Struct>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-struct.rs:21:9
--> $DIR/ref-struct.rs:22:9
|
LL | fn pin_ref_Struct(self: Pin<&Struct>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -40,11 +40,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn pin_ref_Struct<'a>(self: Pin<&'a Struct>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn pin_ref_Struct<'a>(self: Pin<&Struct>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-struct.rs:26:9
--> $DIR/ref-struct.rs:27:9
|
LL | fn box_box_ref_Struct(self: Box<Box<&Struct>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -55,11 +55,11 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_box_ref_Struct<'a>(self: Box<Box<&'a Struct>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_box_ref_Struct<'a>(self: Box<Box<&Struct>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: lifetime may not live long enough
--> $DIR/ref-struct.rs:31:9
--> $DIR/ref-struct.rs:32:9
|
LL | fn box_pin_Struct(self: Box<Pin<&Struct>>, f: &u32) -> &u32 {
| - - let's call the lifetime of this reference `'1`
@ -70,8 +70,8 @@ LL | f
|
help: consider introducing a named lifetime parameter and update trait if needed
|
LL | fn box_pin_Struct<'a>(self: Box<Pin<&'a Struct>>, f: &'a u32) -> &u32 {
| ++++ ++ ++
LL | fn box_pin_Struct<'a>(self: Box<Pin<&Struct>>, f: &'a u32) -> &'a u32 {
| ++++ ++ ++
error: aborting due to 5 previous errors