From 4336f9d064f18adb9f60c431280951fcac9fd264 Mon Sep 17 00:00:00 2001 From: Ashish Date: Sat, 31 Jul 2021 15:53:36 +0530 Subject: [PATCH 1/7] Add long explanation for E0726 --- compiler/rustc_error_codes/src/error_codes.rs | 1 + .../src/error_codes/E0726.md | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+) create mode 100644 compiler/rustc_error_codes/src/error_codes/E0726.md diff --git a/compiler/rustc_error_codes/src/error_codes.rs b/compiler/rustc_error_codes/src/error_codes.rs index 45d91c2047d41..a05634aa5faaa 100644 --- a/compiler/rustc_error_codes/src/error_codes.rs +++ b/compiler/rustc_error_codes/src/error_codes.rs @@ -424,6 +424,7 @@ E0720: include_str!("./error_codes/E0720.md"), E0722: include_str!("./error_codes/E0722.md"), E0724: include_str!("./error_codes/E0724.md"), E0725: include_str!("./error_codes/E0725.md"), +E0725: include_str!("./error_codes/E0726.md"), E0727: include_str!("./error_codes/E0727.md"), E0728: include_str!("./error_codes/E0728.md"), E0729: include_str!("./error_codes/E0729.md"), diff --git a/compiler/rustc_error_codes/src/error_codes/E0726.md b/compiler/rustc_error_codes/src/error_codes/E0726.md new file mode 100644 index 0000000000000..f6251c3683f1d --- /dev/null +++ b/compiler/rustc_error_codes/src/error_codes/E0726.md @@ -0,0 +1,19 @@ +A lifetime indication has not been added to specify the span of your type. + +Erroneous code example: + +```rust +struct Abc<'a> { + title: &'a str, +} + +struct SomeStruct; + +impl SomeStruct { + pub fn some_fn(&self, abc: Abc) { // error: implicit elided lifetime not allowed here rustc(E0726) + // ... + } +} +``` + +Specify the lifetime of struct `Abc` or indicate the anonymous lifetime like `abc: Abc<'_>`. From 02af45c64cf8776c3cbba67b132746b004562f31 Mon Sep 17 00:00:00 2001 From: Ashish Date: Sat, 31 Jul 2021 22:53:28 +0530 Subject: [PATCH 2/7] E0726: add more information and fix error label in macro Duplicate E0725 was added in register_diagnostics macro and explain the error more. --- compiler/rustc_error_codes/src/error_codes.rs | 2 +- .../src/error_codes/E0726.md | 32 +++++++++++++------ 2 files changed, 24 insertions(+), 10 deletions(-) diff --git a/compiler/rustc_error_codes/src/error_codes.rs b/compiler/rustc_error_codes/src/error_codes.rs index a05634aa5faaa..f543be5b6ffc6 100644 --- a/compiler/rustc_error_codes/src/error_codes.rs +++ b/compiler/rustc_error_codes/src/error_codes.rs @@ -424,7 +424,7 @@ E0720: include_str!("./error_codes/E0720.md"), E0722: include_str!("./error_codes/E0722.md"), E0724: include_str!("./error_codes/E0724.md"), E0725: include_str!("./error_codes/E0725.md"), -E0725: include_str!("./error_codes/E0726.md"), +E0726: include_str!("./error_codes/E0726.md"), E0727: include_str!("./error_codes/E0727.md"), E0728: include_str!("./error_codes/E0728.md"), E0729: include_str!("./error_codes/E0729.md"), diff --git a/compiler/rustc_error_codes/src/error_codes/E0726.md b/compiler/rustc_error_codes/src/error_codes/E0726.md index f6251c3683f1d..24b9003fb4a16 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0726.md +++ b/compiler/rustc_error_codes/src/error_codes/E0726.md @@ -1,19 +1,33 @@ -A lifetime indication has not been added to specify the span of your type. +When a struct or a type is bound/declared with a lifetime it is important for the Rust compiler to know, on usage, the lifespan of the type. When the lifetime is not explicitly mentioned and the Rust Compiler cannot determine the lifetime of your type the following error occurs. Erroneous code example: -```rust -struct Abc<'a> { +```compile_fail,E0726 +use futures::executor::block_on; + +struct Content<'a> { title: &'a str, + body: &'a str, } -struct SomeStruct; +struct Blog; + +impl Blog { + pub async fn create(content: Content) { // error[E0726]: implicit elided lifetime not allowed here + println!("title: {}", content.title); + println!("body: {}", content.body); + } +} -impl SomeStruct { - pub fn some_fn(&self, abc: Abc) { // error: implicit elided lifetime not allowed here rustc(E0726) - // ... - } +fn main() { + let content = Content{ title: "Rust", body: "is great!" }; + let future = Blog::create(content); + block_on(future); } ``` -Specify the lifetime of struct `Abc` or indicate the anonymous lifetime like `abc: Abc<'_>`. +Specify desired lifetime of parameter `content` or indicate the anonymous lifetime like `content: Content<'_>`. The anonymous lifetime tells the Rust compiler that `content` is only needed until create function is done with it's execution. + +The `implicit elision` meaning the omission of suggested lifetime that is `pub async fn create<'a>(content: Content<'a>) {}` is not allowed here as lifetime of the `content` can differ from current context. + +Know more about lifetime elision in this [chapter](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision) and a chapter on lifetimes can be found [here](https://doc.rust-lang.org/rust-by-example/scope/lifetime.html). From 2a3b555271b3c5df1859bd0c98483d363cd8a7de Mon Sep 17 00:00:00 2001 From: Ashish Date: Sat, 31 Jul 2021 23:39:11 +0530 Subject: [PATCH 3/7] E0726: fix lint and remove from pending error codes --- .../src/error_codes/E0726.md | 24 +++++++++++++++---- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/compiler/rustc_error_codes/src/error_codes/E0726.md b/compiler/rustc_error_codes/src/error_codes/E0726.md index 24b9003fb4a16..f5731dd23c3eb 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0726.md +++ b/compiler/rustc_error_codes/src/error_codes/E0726.md @@ -1,4 +1,7 @@ -When a struct or a type is bound/declared with a lifetime it is important for the Rust compiler to know, on usage, the lifespan of the type. When the lifetime is not explicitly mentioned and the Rust Compiler cannot determine the lifetime of your type the following error occurs. +When a struct or a type is bound/declared with a lifetime it is important for +the Rust compiler to know, on usage, the lifespan of the type. When the +lifetime is not explicitly mentioned and the Rust Compiler cannot determine +the lifetime of your type the following error occurs. Erroneous code example: @@ -13,7 +16,8 @@ struct Content<'a> { struct Blog; impl Blog { - pub async fn create(content: Content) { // error[E0726]: implicit elided lifetime not allowed here + pub async fn create(content: Content) { // error: implicit elided + // lifetime not allowed here println!("title: {}", content.title); println!("body: {}", content.body); } @@ -26,8 +30,18 @@ fn main() { } ``` -Specify desired lifetime of parameter `content` or indicate the anonymous lifetime like `content: Content<'_>`. The anonymous lifetime tells the Rust compiler that `content` is only needed until create function is done with it's execution. +Specify desired lifetime of parameter `content` or indicate the anonymous +lifetime like `content: Content<'_>`. The anonymous lifetime tells the Rust +compiler that `content` is only needed until create function is done with +it's execution. -The `implicit elision` meaning the omission of suggested lifetime that is `pub async fn create<'a>(content: Content<'a>) {}` is not allowed here as lifetime of the `content` can differ from current context. +The `implicit elision` meaning the omission of suggested lifetime that is +`pub async fn create<'a>(content: Content<'a>) {}` is not allowed here as +lifetime of the `content` can differ from current context. -Know more about lifetime elision in this [chapter](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision) and a chapter on lifetimes can be found [here](https://doc.rust-lang.org/rust-by-example/scope/lifetime.html). +Know more about lifetime elision in this +[chapter][lifetime-elision] and a chapter on lifetimes can be found +[here][lifetimes]. + +[lifetime-elision]: https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision +[lifetimes]: https://doc.rust-lang.org/rust-by-example/scope/lifetime.html \ No newline at end of file From adcb9b96fcce38d7d03049639dbc7d309af8defd Mon Sep 17 00:00:00 2001 From: Ashish Date: Sat, 31 Jul 2021 23:55:39 +0530 Subject: [PATCH 4/7] E0726: remove trailing whitespaces --- .../src/error_codes/E0726.md | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/compiler/rustc_error_codes/src/error_codes/E0726.md b/compiler/rustc_error_codes/src/error_codes/E0726.md index f5731dd23c3eb..ea419565c754b 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0726.md +++ b/compiler/rustc_error_codes/src/error_codes/E0726.md @@ -1,6 +1,6 @@ -When a struct or a type is bound/declared with a lifetime it is important for -the Rust compiler to know, on usage, the lifespan of the type. When the -lifetime is not explicitly mentioned and the Rust Compiler cannot determine +When a struct or a type is bound/declared with a lifetime it is important for +the Rust compiler to know, on usage, the lifespan of the type. When the +lifetime is not explicitly mentioned and the Rust Compiler cannot determine the lifetime of your type the following error occurs. Erroneous code example: @@ -16,7 +16,7 @@ struct Content<'a> { struct Blog; impl Blog { - pub async fn create(content: Content) { // error: implicit elided + pub async fn create(content: Content) { // error: implicit elided // lifetime not allowed here println!("title: {}", content.title); println!("body: {}", content.body); @@ -30,18 +30,18 @@ fn main() { } ``` -Specify desired lifetime of parameter `content` or indicate the anonymous -lifetime like `content: Content<'_>`. The anonymous lifetime tells the Rust -compiler that `content` is only needed until create function is done with +Specify desired lifetime of parameter `content` or indicate the anonymous +lifetime like `content: Content<'_>`. The anonymous lifetime tells the Rust +compiler that `content` is only needed until create function is done with it's execution. -The `implicit elision` meaning the omission of suggested lifetime that is -`pub async fn create<'a>(content: Content<'a>) {}` is not allowed here as +The `implicit elision` meaning the omission of suggested lifetime that is +`pub async fn create<'a>(content: Content<'a>) {}` is not allowed here as lifetime of the `content` can differ from current context. -Know more about lifetime elision in this +Know more about lifetime elision in this [chapter][lifetime-elision] and a chapter on lifetimes can be found [here][lifetimes]. [lifetime-elision]: https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-elision -[lifetimes]: https://doc.rust-lang.org/rust-by-example/scope/lifetime.html \ No newline at end of file +[lifetimes]: https://doc.rust-lang.org/rust-by-example/scope/lifetime.html From 58fdba891e3a9267cb2c7504cdf6f3b9f46660d5 Mon Sep 17 00:00:00 2001 From: Ashish Date: Thu, 5 Aug 2021 09:28:25 +0530 Subject: [PATCH 5/7] E0726: add explain information at the bottom of stderr --- src/test/ui/async-await/async-fn-path-elision.stderr | 1 + src/test/ui/impl-header-lifetime-elision/path-elided.stderr | 1 + src/test/ui/impl-header-lifetime-elision/trait-elided.stderr | 1 + src/test/ui/issues/issue-10412.stderr | 1 + src/test/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr | 1 + 5 files changed, 5 insertions(+) diff --git a/src/test/ui/async-await/async-fn-path-elision.stderr b/src/test/ui/async-await/async-fn-path-elision.stderr index 36fb73a8dde24..3d18d9c412596 100644 --- a/src/test/ui/async-await/async-fn-path-elision.stderr +++ b/src/test/ui/async-await/async-fn-path-elision.stderr @@ -8,3 +8,4 @@ LL | async fn error(lt: HasLifetime) { error: aborting due to previous error +For more information about this error, try `rustc --explain E0726`. diff --git a/src/test/ui/impl-header-lifetime-elision/path-elided.stderr b/src/test/ui/impl-header-lifetime-elision/path-elided.stderr index 1c81c69620165..90522a885ab90 100644 --- a/src/test/ui/impl-header-lifetime-elision/path-elided.stderr +++ b/src/test/ui/impl-header-lifetime-elision/path-elided.stderr @@ -8,3 +8,4 @@ LL | impl MyTrait for Foo { error: aborting due to previous error +For more information about this error, try `rustc --explain E0726`. diff --git a/src/test/ui/impl-header-lifetime-elision/trait-elided.stderr b/src/test/ui/impl-header-lifetime-elision/trait-elided.stderr index 735f01379f09f..15bc3f106b9c4 100644 --- a/src/test/ui/impl-header-lifetime-elision/trait-elided.stderr +++ b/src/test/ui/impl-header-lifetime-elision/trait-elided.stderr @@ -8,3 +8,4 @@ LL | impl MyTrait for u32 { error: aborting due to previous error +For more information about this error, try `rustc --explain E0726`. diff --git a/src/test/ui/issues/issue-10412.stderr b/src/test/ui/issues/issue-10412.stderr index 053a93e6cd8c7..00308389ca961 100644 --- a/src/test/ui/issues/issue-10412.stderr +++ b/src/test/ui/issues/issue-10412.stderr @@ -67,4 +67,5 @@ LL | trait Serializable<'self, T: ?Sized> { error: aborting due to 9 previous errors +Some errors have detailed explanations: E0726. For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr b/src/test/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr index 4e927cd983d0d..bc2f19d19bfa2 100644 --- a/src/test/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr +++ b/src/test/ui/wf/wf-in-foreign-fn-decls-issue-80468.stderr @@ -30,3 +30,4 @@ LL | impl Trait for Ref {} error: aborting due to 2 previous errors +For more information about this error, try `rustc --explain E0726`. From bfdaf67541a45c2a324961437b2cd361a465f8b9 Mon Sep 17 00:00:00 2001 From: Ashish Date: Tue, 28 Sep 2021 09:11:10 +0530 Subject: [PATCH 6/7] E0726: fix example and short description --- .../src/error_codes/E0726.md | 22 ++++++++----------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/compiler/rustc_error_codes/src/error_codes/E0726.md b/compiler/rustc_error_codes/src/error_codes/E0726.md index ea419565c754b..2e08a490a9127 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0726.md +++ b/compiler/rustc_error_codes/src/error_codes/E0726.md @@ -1,3 +1,5 @@ +An argument lifetime was elided in an async function. + When a struct or a type is bound/declared with a lifetime it is important for the Rust compiler to know, on usage, the lifespan of the type. When the lifetime is not explicitly mentioned and the Rust Compiler cannot determine @@ -13,21 +15,15 @@ struct Content<'a> { body: &'a str, } -struct Blog; - -impl Blog { - pub async fn create(content: Content) { // error: implicit elided - // lifetime not allowed here - println!("title: {}", content.title); - println!("body: {}", content.body); - } +async fn create(content: Content) { // error: implicit elided + // lifetime not allowed here + println!("title: {}", content.title); + println!("body: {}", content.body); } -fn main() { - let content = Content{ title: "Rust", body: "is great!" }; - let future = Blog::create(content); - block_on(future); -} +let content = Content{ title: "Rust", body: "is great!" }; +let future = create(content); +block_on(future); ``` Specify desired lifetime of parameter `content` or indicate the anonymous From 6fe2ef5669333edfd3727db9215b3384e2ab9209 Mon Sep 17 00:00:00 2001 From: Ashish Date: Tue, 28 Sep 2021 10:14:06 +0530 Subject: [PATCH 7/7] E0726: accepted wrong change on rebase conflict --- compiler/rustc_error_codes/src/error_codes.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/compiler/rustc_error_codes/src/error_codes.rs b/compiler/rustc_error_codes/src/error_codes.rs index f543be5b6ffc6..3a50337d2ba64 100644 --- a/compiler/rustc_error_codes/src/error_codes.rs +++ b/compiler/rustc_error_codes/src/error_codes.rs @@ -640,7 +640,6 @@ E0785: include_str!("./error_codes/E0785.md"), E0717, // rustc_promotable without stability attribute // E0721, // `await` keyword // E0723, unstable feature in `const` context - E0726, // non-explicit (not `'_`) elided lifetime in unsupported position // E0738, // Removed; errored on `#[track_caller] fn`s in `extern "Rust" { ... }`. E0772, // `'static' obligation coming from `impl dyn Trait {}` or `impl Foo for dyn Bar {}`. }