Detect pub structs never constructed

Author: mu001999

compiler/rustc_passes/src/dead.rs

@@ -15,7 +15,7 @@ use rustc_hir::{Node, PatKind, TyKind};
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::privacy::Level;
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, TyCtxt};
+use rustc_middle::ty::{self, AssocItemContainer, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
 use rustc_session::lint::builtin::DEAD_CODE;
@@ -44,16 +44,38 @@ fn should_explore(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     )
 }
 
+fn struct_all_fields_are_public(tcx: TyCtxt<'_>, id: DefId) -> bool {
+    tcx.adt_def(id).all_fields().all(|field| field.vis.is_public())
+}
+
+/// pub struct whose fields are all public
+fn ty_ref_to_pure_pub_struct(tcx: TyCtxt<'_>, ty: &hir::Ty<'_>) -> bool {
+    if let TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
+        && let Res::Def(def_kind, def_id) = path.res
+        && def_id.is_local()
+    {
+        return match def_kind {
+            DefKind::Enum | DefKind::Union => tcx.visibility(def_id).is_public(),
+            DefKind::Struct => {
+                tcx.visibility(def_id).is_public() && struct_all_fields_are_public(tcx, def_id)
+            }
+            _ => true,
+        };
+    }
+
+    true
+}
+
+/// pub struct but may have private fields
 fn ty_ref_to_pub_struct(tcx: TyCtxt<'_>, ty: &hir::Ty<'_>) -> bool {
     if let TyKind::Path(hir::QPath::Resolved(_, path)) = ty.kind
         && let Res::Def(def_kind, def_id) = path.res
         && def_id.is_local()
-        && matches!(def_kind, DefKind::Struct | DefKind::Enum | DefKind::Union)
+        && matches!(def_kind, DefKind::Enum | DefKind::Union | DefKind::Struct)
     {
-        tcx.visibility(def_id).is_public()
-    } else {
-        true
+        return tcx.visibility(def_id).is_public();
     }
+    true
 }
 
 /// Determine if a work from the worklist is coming from the a `#[allow]`
@@ -426,10 +448,11 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
                                 self.tcx.hir().expect_item(local_impl_id).kind
                         {
                             if matches!(trait_item.kind, hir::TraitItemKind::Fn(..))
-                                && !ty_ref_to_pub_struct(self.tcx, impl_ref.self_ty)
+                                && !ty_ref_to_pure_pub_struct(self.tcx, impl_ref.self_ty)
                             {
-                                // skip methods of private ty,
-                                // they would be solved in `solve_rest_impl_items`
+                                // skip impl-items of non pure pub ty,
+                                // cause we don't know the ty is constructed or not,
+                                // check these later in `solve_rest_impl_items`
                                 continue;
                             }
 
@@ -510,22 +533,21 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
             && let Some(local_def_id) = def_id.as_local()
             && matches!(def_kind, DefKind::Struct | DefKind::Enum | DefKind::Union)
         {
-            if self.tcx.visibility(impl_item_id).is_public() {
-                // for the public method, we don't know the trait item is used or not,
-                // so we mark the method live if the self is used
-                return self.live_symbols.contains(&local_def_id);
-            }
-
             if let Some(trait_item_id) = self.tcx.associated_item(impl_item_id).trait_item_def_id
                 && let Some(local_id) = trait_item_id.as_local()
             {
-                // for the private method, we can know the trait item is used or not,
+                // for the local impl item, we can know the trait item is used or not,
                 // so we mark the method live if the self is used and the trait item is used
-                return self.live_symbols.contains(&local_id)
-                    && self.live_symbols.contains(&local_def_id);
+                self.live_symbols.contains(&local_id) && self.live_symbols.contains(&local_def_id)
+            } else {
+                // for the foreign method and inherent pub method,
+                // we don't know the trait item or the method is used or not,
+                // so we mark the method live if the self is used
+                self.live_symbols.contains(&local_def_id)
             }
+        } else {
+            false
         }
-        false
     }
 }
 
@@ -747,7 +769,8 @@ fn check_item<'tcx>(
                 .iter()
                 .filter_map(|def_id| def_id.as_local());
 
-            let ty_is_pub = ty_ref_to_pub_struct(tcx, tcx.hir().item(id).expect_impl().self_ty);
+            let self_ty = tcx.hir().item(id).expect_impl().self_ty;
+            let ty_is_pure_pub = ty_ref_to_pure_pub_struct(tcx, self_ty);
 
             // And we access the Map here to get HirId from LocalDefId
             for local_def_id in local_def_ids {
@@ -766,15 +789,29 @@ fn check_item<'tcx>(
                 if of_trait
                     && (!matches!(tcx.def_kind(local_def_id), DefKind::AssocFn)
                         || tcx.visibility(local_def_id).is_public()
-                            && (ty_is_pub || may_construct_self))
+                            && (ty_is_pure_pub || may_construct_self))
+                {
+                    // if the impl item is public,
+                    // and the ty may be constructed or can be constructed in foreign crates,
+                    // mark the impl item live
+                    worklist.push((local_def_id, ComesFromAllowExpect::No));
+                } else if !of_trait
+                    && tcx.visibility(local_def_id).is_public()
+                    && (ty_is_pure_pub || may_construct_self)
                 {
+                    // if the impl item is public,
+                    // and the ty may be constructed or can be constructed in foreign crates,
+                    // mark the impl item live
                     worklist.push((local_def_id, ComesFromAllowExpect::No));
                 } else if let Some(comes_from_allow) =
                     has_allow_dead_code_or_lang_attr(tcx, local_def_id)
                 {
                     worklist.push((local_def_id, comes_from_allow));
-                } else if of_trait {
-                    // private method || public method not constructs self
+                } else if of_trait
+                    || tcx.visibility(local_def_id).is_public()
+                        && ty_ref_to_pub_struct(tcx, self_ty)
+                {
+                    // private impl items of traits || public impl items not constructs self
                     unsolved_impl_items.push((id, local_def_id));
                 }
             }
@@ -841,6 +878,14 @@ fn create_and_seed_worklist(
             effective_vis
                 .is_public_at_level(Level::Reachable)
                 .then_some(id)
+                .filter(|&id|
+                    // checks impls, impl-items and pub structs with all public fields later
+                    match tcx.def_kind(id) {
+                        DefKind::Impl { .. } => false,
+                        DefKind::AssocFn => !matches!(tcx.associated_item(id).container, AssocItemContainer::ImplContainer),
+                        DefKind::Struct => struct_all_fields_are_public(tcx, id.to_def_id()),
+                        _ => true
+                    })
                 .map(|id| (id, ComesFromAllowExpect::No))
         })
         // Seed entry point
@@ -1116,6 +1161,9 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalModDefId) {
                 // We have diagnosed unused methods in traits
                 if matches!(def_kind, DefKind::Impl { of_trait: true })
                     && tcx.def_kind(def_id) == DefKind::AssocFn
+                    // skip unused public inherent methods,
+                    // cause we have diagnosed unconstructed struct
+                    || matches!(def_kind, DefKind::Impl { of_trait: false }) && tcx.visibility(def_id).is_public() && ty_ref_to_pub_struct(tcx, tcx.hir().item(item).expect_impl().self_ty)
                     || def_kind == DefKind::Trait && tcx.def_kind(def_id) != DefKind::AssocFn
                 {
                     continue;

library/core/src/clone.rs

@@ -184,6 +184,7 @@ pub macro Clone($item:item) {
 //
 // These structs should never appear in user code.
 #[doc(hidden)]
+#[allow(dead_code)]
 #[allow(missing_debug_implementations)]
 #[unstable(
     feature = "derive_clone_copy",
@@ -194,6 +195,7 @@ pub struct AssertParamIsClone<T: Clone + ?Sized> {
     _field: crate::marker::PhantomData<T>,
 }
 #[doc(hidden)]
+#[allow(dead_code)]
 #[allow(missing_debug_implementations)]
 #[unstable(
     feature = "derive_clone_copy",

tests/ui/lint/dead-code/unused_pub_struct.rs

@@ -0,0 +1,37 @@
+#![deny(dead_code)]
+
+pub struct NeverConstructed(()); //~ ERROR struct `NeverConstructed` is never constructed
+
+impl NeverConstructed {
+    pub fn not_construct_self(&self) {}
+}
+
+impl Clone for NeverConstructed {
+    fn clone(&self) -> NeverConstructed {
+        NeverConstructed(())
+    }
+}
+
+pub trait Trait {
+    fn not_construct_self(&self) {}
+}
+
+impl Trait for NeverConstructed {}
+
+pub struct Constructed(());
+
+impl Constructed {
+    pub fn construct_self() -> Self {
+        Constructed(())
+    }
+}
+
+impl Clone for Constructed {
+    fn clone(&self) -> Constructed {
+        Constructed(())
+    }
+}
+
+impl Trait for Constructed {}
+
+fn main() {}

tests/ui/lint/dead-code/unused_pub_struct.stderr

@@ -0,0 +1,14 @@
+error: struct `NeverConstructed` is never constructed
+  --> $DIR/unused_pub_struct.rs:3:12
+   |
+LL | pub struct NeverConstructed(());
+   |            ^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/unused_pub_struct.rs:1:9
+   |
+LL | #![deny(dead_code)]
+   |         ^^^^^^^^^
+
+error: aborting due to 1 previous error
+