diagnostics: dead_code does not track trait impls (false negative: unused struct with Clone derived)

[matthiaskrgr]

there's no dead_code warning for

#[derive(Clone)]
struct A {
    b: i32,
}

fn main(){}

while

struct A {
    b: i32,
}

fn main(){}

correctly warns:

warning: struct is never constructed: `A`
 --> src/main.rs:2:1
  |
2 | struct A {
  | ^^^^^^^^
  |
  = note: #[warn(dead_code)] on by default

reproduces with stable 1.31.1, beta 1.32.0-beta.14 and nightly 1.33.0 2019.01.13

[jethrogb]

Dupe of #47851

[matthiaskrgr]

Interesting..

why is this only a problem for #[derive(Clone)] but not for #[derive(Debug)] though?

[jethrogb]

I'm guessing because clone returns Self

[jakubadamw]

Is this really a bug? Surely, in the case of a struct with Clone derived emitting that particular warning that we see in the second example would itself be a bug, because the implementation of Clone does in fact construct a struct of the type it's provided for. Yes, there could perhaps be another class of warning such as: struct is never constructed independently of an existing value of that struct's type. Is it, however, in scope for this lint to reason about construction sites like this? I'm not sure. I think it's fair game for this lint to give non-trivial false negatives. It's a bug if it gives false positives.

[SimonSapin]

If you come up with a very simple definition of "used" and apply it literally, then yes the struct is used in the Clone impl and not emitting a warning is correct by that definition.

That’s not to say that such a definition is a useful one. In this case it’s clear that this struct is dead code. In the spirit of the what motivates this lint to exist, a warning should be emitted. In fact, the very simple definition is not the one currently in rustc:

struct Foo;

fn foo() {
    let _ = Foo;
}

(Playground)

Output:

warning: struct is never constructed: `Foo`
 --> src/lib.rs:1:1
  |
1 | struct Foo;
  | ^^^^^^^^^^^
  |
  = note: #[warn(dead_code)] on by default

warning: function is never used: `foo`
 --> src/lib.rs:3:1
  |
3 | fn foo() {
  | ^^^^^^^^

The Foo struct is used in the foo function, but since the function itself is unused that used is considered not to count. This propagation is useful.

It appears that the real issue here is that (methods of) trait impl are not tracked as used/unused the way functions are.

[jonas-schievink]

Closing as a duplicate of #47851