mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
151256bd4b
rust/tests/ui/lint/unused/unused-closure.stderr

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

66 lines
1.6 KiB
Plaintext
Raw Normal View History

Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
error: unused closure that must be used
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:9:5
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | / || {
LL | | println!("Hello!");
LL | | };
Tweak span for `#[must_use]` Do not point at whole statement, only at the expression (skip pointing at `;`)
2022-08-16 09:46:33 -05:00
| |_____^
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
bless ui tests
2022-09-18 10:55:36 -05:00
= note: closures are lazy and do nothing unless called
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
note: the lint level is defined here
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:6:9
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | #![deny(unused_must_use)]
| ^^^^^^^^^^^^^^^
pretty: trim paths of unique symbols If a symbol name can only be imported from one place for a type, and as long as it was not glob-imported anywhere in the current crate, we can trim its printed path and print only the name. This has wide implications on error messages with types, for example, shortening `std::vec::Vec` to just `Vec`, as long as there is no other `Vec` importable anywhere. This adds a new '-Z trim-diagnostic-paths=false' option to control this feature. On the good path, with no diagnosis printed, we should try to avoid issuing this query, so we need to prevent trimmed_def_paths query on several cases. This change also relies on a previous commit that differentiates between `Debug` and `Display` on various rustc types, where the latter is trimmed and presented to the user and the former is not.
2020-09-02 02:40:56 -05:00
error: unused implementer of `Future` that must be used
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:13:5
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | async {};
Tweak span for `#[must_use]` Do not point at whole statement, only at the expression (skip pointing at `;`)
2022-08-16 09:46:33 -05:00
| ^^^^^^^^
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
= note: futures do nothing unless you `.await` or poll them
error: unused closure that must be used
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:14:5
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | || async {};
Tweak span for `#[must_use]` Do not point at whole statement, only at the expression (skip pointing at `;`)
2022-08-16 09:46:33 -05:00
| ^^^^^^^^^^^
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
= note: closures are lazy and do nothing unless called
error: unused closure that must be used
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:15:5
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | async || {};
Tweak span for `#[must_use]` Do not point at whole statement, only at the expression (skip pointing at `;`)
2022-08-16 09:46:33 -05:00
| ^^^^^^^^^^^
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
= note: closures are lazy and do nothing unless called
error: unused array of boxed arrays of closures that must be used
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:18:5
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | [Box::new([|| {}; 10]); 1];
Tweak span for `#[must_use]` Do not point at whole statement, only at the expression (skip pointing at `;`)
2022-08-16 09:46:33 -05:00
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
= note: closures are lazy and do nothing unless called
error: unused closure that must be used
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:20:5
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | vec![|| "a"].pop().unwrap();
Tweak span for `#[must_use]` Do not point at whole statement, only at the expression (skip pointing at `;`)
2022-08-16 09:46:33 -05:00
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
= note: closures are lazy and do nothing unless called
error: unused closure that must be used
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
--> $DIR/unused-closure.rs:23:9
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
LL | || true;
Tweak span for `#[must_use]` Do not point at whole statement, only at the expression (skip pointing at `;`)
2022-08-16 09:46:33 -05:00
| ^^^^^^^
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
|
= note: closures are lazy and do nothing unless called
Remove const_in_array_rep_expr
2021-01-26 16:49:30 -06:00
error: aborting due to 7 previous errors
Make closures and generators a must use types Warn about unused expressions with closure or generator type. This follows existing precedence of must use annotations present on `FnOnce`, `FnMut`, `Fn` traits, which already indirectly apply to closures in some cases, e.g.,: ```rust fn f() -> impl FnOnce() { || {} } fn main() { // an existing warning: unused implementer of `std::ops::FnOnce` that must be used: f(); // a new warning: unused closure that must be used: || {}; } ```
2020-07-27 19:00:00 -05:00
Reference in New Issue Copy Permalink