let-underscore-must-use is triggered when Debug is derived

[ArekPiekarz]

cargo clippy -V: clippy 0.0.212 (c807fbc 2019-12-29)
rustc -V: rustc 1.42.0-nightly (da3629b 2019-12-29)

Summary

Deriving Debug on a struct with at least one field triggers let-underscore-must-use lint.

Steps to reproduce

Given the following code:

#[derive(Debug)]
struct Foo {
    field: i32,
}

fn main() {
}

When cargo clippy -- -W clippy::let-underscore-must-use is run it emits a warning:

warning: non-binding let on an expression with #[must_use] type
 --> src/main.rs:1:10
  |
1 | #[derive(Debug)]
  |          ^^^^^
  |
  = note: requested on the command line with `-W clippy::let-underscore-must-use`
  = help: consider explicitly using expression value
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use

If we run cargo expand, we can see the compiler generates an anonymous binding indeed:

#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Foo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match *self {
            Foo {
                field: ref __self_0_0,
            } => {
                let mut debug_trait_builder = f.debug_struct("Foo");
                let _ = debug_trait_builder.field("field", &&(*__self_0_0));
                debug_trait_builder.finish()
            }
        }
    }
}

[ghost]

Here is some analysis of what is going on.

Running cargo expand on the sample shows that this impl block is generated:

#[automatically_derived]
#[allow(unused_qualifications)]
impl ::core::fmt::Debug for Foo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match *self {
            Foo {
                field: ref __self_0_0,
            } => {
                let mut debug_trait_builder = f.debug_struct("Foo");
                let _ = debug_trait_builder.field("field", &&(*__self_0_0));
                debug_trait_builder.finish()
            }
        }
    }
}

debug_trait_builder has type DebugStruct. This type is must_use because it has the attribute #[must_use = "must eventually call ``finish()`` on Debug builders"]. field() is a builder method which returns a reference todebug_trait_builder. (Normally you'd just chain these calls like the DebugStruct documentation shows.) finish is correctly called on this struct on the next line.

It's a bug in the lint but I'm not sure what the best way of fixing it would be.

[ArekPiekarz]

There are two separate problems here:

1. Detecting if DebugStruct is used.
2. Detecting if DebugStruct is used correctly.

The second one relates to the need to call finish() after configuring the builder. I think currently it's not possible to express that relation in the language. The only thing that comes close is using a typestate pattern, so the finish method would consume the builder, but currently it accepts &mut self. Because of that this point could be deferred into the future.

The first one could be solved by checking if the object pointed by the reference is used, not just the reference returned from the function. I don't know if Clippy is capable of such call analysis, especially when in general the object could be passed away from the place of its construction and used much later in some other part of the program.

[flip1995]

I think it's save to just disable this lint in external macros.

[jendrikw]

This is still an issue when using other crates to derive traits. Here is an example using derivative to derive Debug, which fires a FP.

playground

#![deny(clippy::let_underscore_must_use)]

use derivative::Derivative; // 2.2.0

#[derive(Derivative)]
#[derivative(Debug)]
struct S {
    x: i32,
}

Output from clippy:

error: non-binding let on an expression with `#[must_use]` type
 --> src/lib.rs:7:8
  |
7 | struct S {
  |        ^
  |
note: the lint level is defined here
 --> src/lib.rs:1:9
  |
1 | #![deny(clippy::let_underscore_must_use)]
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  = help: consider explicitly using expression value
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use