#[must_use] does not work for nested structures

[sunjay]

When #[must_use] is applied to a structure that is nested, the linter no longer picks up when that value is unused.

This is related to: #26291 and #26281

Looking at those issues, there seem to be a lot of cases where #[must_use] does not work. This is unfortunate because it is actually an incredibly useful annotation that definitely has applications past just the Result enum.

Accidentally relying on it too much can have you make mistakes you otherwise would have corrected had the warning been a bit smarter. I consider this a bug because #[must_use] implies that you must use that value no matter what; regardless of what form it is returned in.

I tried this code: (Rust Playground: https://is.gd/vCLZKq)

#[must_use]
#[derive(Debug)]
struct MustUse;

struct Foo {
    must: MustUse,
}

impl Foo {
    fn bar(&self) {
        println!("{:?}", self.must);
    }
}

fn must() -> Foo {
    Foo {must: MustUse}
}

fn main() {
    must().bar();
    must();
}

I expected to see this happen: A warning about the MustUse structure not being used

Instead, this happened: The code compiled and ran with no errors

Meta

rustc --version --verbose: stable, nightly, etc.

Backtrace: not applicable

[mitsuhiko]

This definitely comes up with Option<Result<T, E>>. Since .map can produce something like this easily that is not great.

[varkor]

I think this should essentially be considered a straightforward extension of #61061 (which extended #[must_use] to tuples). I have a WIP branch that extends #[must_use] to nested user-defined structures like this, but it needs some cleaning up.

[varkor]

Closed as not being desirable in #62262 (comment). We would need a more nuanced handling of #[must_use], which would require an RFC.

[jebrosen]

I see this was rejected in general, but would it be doable to special case it for Pin the way it is for Box? It is not uncommon to have a Pin<Box<dyn Future>> especially when working with something like async-trait, but Pin does not propagate #[must_use]: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=51b7e0669d9d7462cd0345da4ec9dec8. This can be problematic when refactoring, because it's easy to forget to add the .awaits to every caller when changing functions to return pinned-boxed futures.

[varkor]

@jebrosen: that should be possible — could you open a new issue for this? I'll try to write up some mentoring advice.