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

compiler/rustc_passes/src/dead.rs

@@ -58,6 +58,8 @@ fn local_adt_def_of_ty<'tcx>(ty: &hir::Ty<'tcx>) -> Option<LocalDefId> {
                 None
             }
         }
+        TyKind::Slice(ty) | TyKind::Array(ty, _) => local_adt_def_of_ty(ty),
+        TyKind::Ptr(ty) | TyKind::Ref(_, ty) => local_adt_def_of_ty(ty.ty),
         _ => None,
     }
 }

compiler/rustc_privacy/src/lib.rs

@@ -699,17 +699,31 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
                 // `impl ReachableTrait<UnreachableTy> for ReachableTy<UnreachableTy> { ... }`
                 // can be usable from other crates (#57264). So we skip args when calculating
                 // reachability and consider an impl reachable if its "shallow" type and trait are
-                // reachable.
+                // reachable if there were no private types.
                 //
                 // The assumption we make here is that type-inference won't let you use an impl
                 // without knowing both "shallow" version of its self type and "shallow" version of
                 // its trait if it exists (which require reaching the `DefId`s in them).
-                let item_ev = EffectiveVisibility::of_impl::<true>(
+                let impl_vis = ty::Visibility::of_impl::<false>(
                     item.owner_id.def_id,
                     self.tcx,
-                    &self.effective_visibilities,
+                    &Default::default(),
                 );
 
+                let item_ev = if impl_vis.is_public() {
+                    EffectiveVisibility::of_impl::<true>(
+                        item.owner_id.def_id,
+                        self.tcx,
+                        &self.effective_visibilities,
+                    )
+                } else {
+                    EffectiveVisibility::of_impl::<false>(
+                        item.owner_id.def_id,
+                        self.tcx,
+                        &self.effective_visibilities,
+                    )
+                };
+
                 self.update_eff_vis(item.owner_id.def_id, item_ev, None, Level::Direct);
 
                 self.reach(item.owner_id.def_id, item_ev).generics().predicates().ty().trait_ref();

tests/ui/lint/dead-code/unused-impl-for-non-adts.rs

@@ -0,0 +1,89 @@
+#![deny(dead_code)]
+
+struct Foo; //~ ERROR struct `Foo` is never constructed
+
+trait Trait { //~ ERROR trait `Trait` is never used
+    fn foo(&self);
+}
+
+impl Trait for Foo {
+    fn foo(&self) {}
+}
+
+impl Trait for [Foo] {
+    fn foo(&self) {}
+}
+impl<const N: usize> Trait for [Foo; N] {
+    fn foo(&self) {}
+}
+
+impl Trait for *const Foo {
+    fn foo(&self) {}
+}
+impl Trait for *mut Foo {
+    fn foo(&self) {}
+}
+
+impl Trait for &Foo {
+    fn foo(&self) {}
+}
+impl Trait for &&Foo {
+    fn foo(&self) {}
+}
+impl Trait for &mut Foo {
+    fn foo(&self) {}
+}
+
+impl Trait for [&Foo] {
+    fn foo(&self) {}
+}
+impl Trait for &[Foo] {
+    fn foo(&self) {}
+}
+impl Trait for &*const Foo {
+    fn foo(&self) {}
+}
+
+pub trait Trait2 {
+    fn foo(&self);
+}
+
+impl Trait2 for Foo {
+    fn foo(&self) {}
+}
+
+impl Trait2 for [Foo] {
+    fn foo(&self) {}
+}
+impl<const N: usize> Trait2 for [Foo; N] {
+    fn foo(&self) {}
+}
+
+impl Trait2 for *const Foo {
+    fn foo(&self) {}
+}
+impl Trait2 for *mut Foo {
+    fn foo(&self) {}
+}
+
+impl Trait2 for &Foo {
+    fn foo(&self) {}
+}
+impl Trait2 for &&Foo {
+    fn foo(&self) {}
+}
+impl Trait2 for &mut Foo {
+    fn foo(&self) {}
+}
+
+impl Trait2 for [&Foo] {
+    fn foo(&self) {}
+}
+impl Trait2 for &[Foo] {
+    fn foo(&self) {}
+}
+impl Trait2 for &*const Foo {
+    fn foo(&self) {}
+}
+
+fn main() {}

tests/ui/lint/dead-code/unused-impl-for-non-adts.stderr

@@ -0,0 +1,20 @@
+error: struct `Foo` is never constructed
+  --> $DIR/unused-impl-for-non-adts.rs:3:8
+   |
+LL | struct Foo;
+   |        ^^^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-impl-for-non-adts.rs:1:9
+   |
+LL | #![deny(dead_code)]
+   |         ^^^^^^^^^
+
+error: trait `Trait` is never used
+  --> $DIR/unused-impl-for-non-adts.rs:5:7
+   |
+LL | trait Trait {
+   |       ^^^^^
+
+error: aborting due to 2 previous errors
+