Extend dead code analysis of impls and impl items to non-ADTs

[mu001999]

Then we can lint more unused structs and traits like the following:

struct Foo; //~ ERROR struct `Foo` is never constructed

trait Trait { //~ ERROR trait `Trait` is never used
    fn foo(&self) {}
}

impl Trait for &Foo {}

Extracted from #128637.
r? @petrochenkov

[petrochenkov]

How is this change related to supporting non-ADTs?
Isn't this reverting a part of changes from #141407?
The logic is again spread randomly between the various analysis stages, what is the principle behind all this, what is filtered away or analyzed at what stage?

[mu001999]

Removed this and edited the reachable analysis in the new change

[mu001999]

The logic here is removing impl ReachableTrait for ReachableTy<PrivateTy> from the seed worklist. Because the reachable analysis considers impl ReachableTrait for ReachableTy<UnreachableTy> reachable due to the trait and the "shallow" type are both reachable, but this will also mark impl ReachableTrait for ReachableTy<PrivateTy> and impl ReachableTrait for [PrivateTy]reachable. The latter is not expected.

[petrochenkov]

impl ReachableTrait for ReachableTy<PrivateTy> and impl ReachableTrait for [PrivateTy] may indeed be reachable due to type inference, even it's not intuitive.
(But they will produce an error on use.)

I need to check though, whether we mark private items as reachable in other, non-impl cases.
If we do, then private impls can probably be treated as non-reachable as well.

This is a change that may have language implications.

[mu001999]

@rustbot ready

[petrochenkov]

The cases reported by dead code lint in this PR are most similar to this case.

struct Priv;

pub fn leak_priv() -> Priv { Priv }

leak_priv is considered reachable here despite the fact that it's unusable from other crates due to Priv in its primary interface.
However, potentially we can report it as dead code if it's not used otherwise.

On the other hand marking it reachable is exactly what allows the private_interfaces lint to work correctly.

warning: type `Priv` is more private than the item `leak_priv`

So what we really need is two different "effective visibility" tables, one with the rules making leak_priv reachable and another making it non-reachable.
These tables would then both be used in various places depending on context.

[petrochenkov]

(I'll think about this more tomorrow.)

[mu001999]

I'm thinking about whether it's correct to extend to non-ADT.

Considering the following:

#![deny(dead_code)]

struct T;

fn foo(_: &[T]) {}

struct U;

pub trait Bar {
    fn bar(&self);
}

impl Bar for [U] {
    fn bar(&self) {}
}

fn main() {
    foo(&[]);
    [].bar();
}

This PR will mark U as never constructed, different to T. Although U has not been constructed.

[petrochenkov]

@mu001999
You are right, regardless of reachability, due to type inference we cannot easily detect private uses of such impls as well.

[petrochenkov]

Ok, this extension has enough problems, let's not do this.