Implement unused_pub_items_in_binary lint

Author: mu001999

compiler/rustc_lint_defs/src/builtin.rs

@@ -148,6 +148,7 @@ declare_lint_pass! {
         UNUSED_MACROS,
         UNUSED_MACRO_RULES,
         UNUSED_MUT,
+        UNUSED_PUB_ITEMS_IN_BINARY,
         UNUSED_QUALIFICATIONS,
         UNUSED_UNSAFE,
         UNUSED_VARIABLES,
@@ -784,6 +785,37 @@ declare_lint! {
     "detect unused, unexported items"
 }
 
+declare_lint! {
+    /// The `unused_pub_items_in_binary` lint detects unused `pub` items in
+    /// executable crates.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// #![deny(unused_pub_items_in_binary)]
+    ///
+    /// pub fn unused_pub_fn() {}
+    ///
+    /// fn main() {}
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// In executable crates, `pub` items are often implementation details
+    /// rather than part of an external API. This lint helps find those items
+    /// when they are never used.
+    ///
+    /// This lint only applies to executable crates. In library crates, public
+    /// items are considered part of the crate's API and are not reported by
+    /// this lint.
+    pub UNUSED_PUB_ITEMS_IN_BINARY,
+    Allow,
+    "detect public items in executable crates that are never used",
+    crate_level_only
+}
+
 declare_lint! {
     /// The `unused_attributes` lint detects attributes that were not used by
     /// the compiler.

compiler/rustc_middle/src/middle/dead_code.rs

@@ -11,11 +11,11 @@ pub struct DeadCodeLivenessSnapshot {
     pub ignored_derived_traits: LocalDefIdMap<FxIndexSet<DefId>>,
 }
 
-/// Dead-code liveness data across primary and deferred seeding.
+/// Dead-code liveness data for both analysis phases.
 ///
-/// `pre_deferred_seeding` is computed after the initial analysis pass but before deferred seeds
-/// are added.
-/// `final_result` is the liveness snapshot after all seeds have been processed.
+/// `pre_deferred_seeding` is computed before reachable-public and `#[allow(dead_code)]` seeding,
+/// and is used for lint `unused_pub_items_in_binary`.
+/// `final_result` is the final liveness snapshot used for lint `dead_code`.
 #[derive(Clone, Debug, HashStable)]
 pub struct DeadCodeLivenessSummary {
     pub pre_deferred_seeding: DeadCodeLivenessSnapshot,

compiler/rustc_passes/src/check_attr.rs

@@ -1526,6 +1526,16 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         return;
                     }
                 }
+            } else if hir_id == CRATE_HIR_ID
+                && attr.has_any_name(&[sym::allow, sym::warn, sym::deny, sym::forbid, sym::expect])
+                && let Some(meta) = attr.meta_item_list()
+                && meta.iter().any(|meta| {
+                    meta.meta_item()
+                        .is_some_and(|item| item.path == sym::unused_pub_items_in_binary)
+                })
+                && !self.tcx.crate_types().contains(&CrateType::Executable)
+            {
+                errors::UnusedNote::NoEffectUnusedPubItemsInBinary
             } else if attr.has_name(sym::default_method_body_is_const) {
                 errors::UnusedNote::DefaultMethodBodyConst
             } else {

compiler/rustc_passes/src/dead.rs

@@ -20,12 +20,14 @@ use rustc_middle::middle::privacy::Level;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, AssocTag, TyCtxt};
 use rustc_middle::{bug, span_bug};
-use rustc_session::lint::builtin::DEAD_CODE;
+use rustc_session::config::CrateType;
+use rustc_session::lint::builtin::{DEAD_CODE, UNUSED_PUB_ITEMS_IN_BINARY};
 use rustc_session::lint::{self, Lint, LintExpectationId};
 use rustc_span::{Symbol, kw};
 
 use crate::errors::{
-    ChangeFields, IgnoredDerivedImpls, MultipleDeadCodes, ParentInfo, UselessAssignment,
+    ChangeFields, IgnoredDerivedImpls, MultipleDeadCodes, ParentInfo, UnusedPubItemsInBinaryNote,
+    UselessAssignment,
 };
 
 /// Any local definition that may call something in its body block should be explored. For example,
@@ -1086,6 +1088,13 @@ impl<'tcx> DeadVisitor<'tcx> {
         (level.level, level.lint_id)
     }
 
+    fn unused_pub_items_in_binary_note(&self) -> Option<UnusedPubItemsInBinaryNote> {
+        self.target_lint
+            .name
+            .eq(UNUSED_PUB_ITEMS_IN_BINARY.name)
+            .then_some(UnusedPubItemsInBinaryNote)
+    }
+
     // # Panics
     // All `dead_codes` must have the same lint level, otherwise we will intentionally ICE.
     // This is because we emit a multi-spanned lint using the lint level of the `dead_codes`'s
@@ -1197,6 +1206,7 @@ impl<'tcx> DeadVisitor<'tcx> {
                     descr,
                     participle,
                     name_list,
+                    unused_pub_items_in_binary_note: self.unused_pub_items_in_binary_note(),
                     change_fields_suggestion: fields_suggestion,
                     parent_info,
                     ignored_derived_impls,
@@ -1233,6 +1243,7 @@ impl<'tcx> DeadVisitor<'tcx> {
                     descr,
                     participle,
                     name_list,
+                    unused_pub_items_in_binary_note: self.unused_pub_items_in_binary_note(),
                     parent_info,
                     ignored_derived_impls,
                     enum_variants_with_same_name,
@@ -1308,14 +1319,33 @@ impl<'tcx> DeadVisitor<'tcx> {
 }
 
 fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalModDefId) {
-    let Ok(DeadCodeLivenessSummary { final_result, .. }) =
+    let Ok(DeadCodeLivenessSummary { pre_deferred_seeding, final_result }) =
         tcx.live_symbols_and_ignored_derived_traits(()).as_ref()
     else {
         return;
     };
 
     let module_items = tcx.hir_module_items(module);
 
+    if tcx.crate_types().contains(&CrateType::Executable) {
+        let is_unused_pub = |def_id: LocalDefId| {
+            tcx.effective_visibilities(()).is_public_at_level(def_id, Level::Reachable)
+                && !pre_deferred_seeding.live_symbols.contains(&def_id)
+        };
+
+        lint_dead_code_or_unused_pub_items_in_binary(
+            tcx,
+            UNUSED_PUB_ITEMS_IN_BINARY,
+            module,
+            &pre_deferred_seeding.live_symbols,
+            &pre_deferred_seeding.ignored_derived_traits,
+            module_items.free_items().filter(|free_item| is_unused_pub(free_item.owner_id.def_id)),
+            module_items
+                .foreign_items()
+                .filter(|foreign_item| is_unused_pub(foreign_item.owner_id.def_id)),
+        );
+    }
+
     lint_dead_code_or_unused_pub_items_in_binary(
         tcx,
         DEAD_CODE,

compiler/rustc_passes/src/errors.rs

@@ -298,6 +298,8 @@ pub(crate) enum UnusedNote {
         "the `linker_messages` and `linker_info` lints can only be controlled at the root of a crate that needs to be linked"
     )]
     LinkerMessagesBinaryCrateOnly,
+    #[note("the `unused_pub_items_in_binary` lint has no effect in library crates")]
+    NoEffectUnusedPubItemsInBinary,
 }
 
 #[derive(Diagnostic)]
@@ -920,6 +922,8 @@ pub(crate) enum MultipleDeadCodes<'tcx> {
         participle: &'tcx str,
         name_list: DiagSymbolList,
         #[subdiagnostic]
+        unused_pub_items_in_binary_note: Option<UnusedPubItemsInBinaryNote>,
+        #[subdiagnostic]
         // only on DeadCodes since it's never a problem for tuple struct fields
         enum_variants_with_same_name: Vec<EnumVariantSameName<'tcx>>,
         #[subdiagnostic]
@@ -943,6 +947,8 @@ pub(crate) enum MultipleDeadCodes<'tcx> {
         participle: &'tcx str,
         name_list: DiagSymbolList,
         #[subdiagnostic]
+        unused_pub_items_in_binary_note: Option<UnusedPubItemsInBinaryNote>,
+        #[subdiagnostic]
         change_fields_suggestion: ChangeFields,
         #[subdiagnostic]
         parent_info: Option<ParentInfo<'tcx>>,
@@ -951,6 +957,12 @@ pub(crate) enum MultipleDeadCodes<'tcx> {
     },
 }
 
+#[derive(Subdiagnostic)]
+#[note(
+    "in libraries, `pub` items can be used by dependent crates; in binaries, they cannot, so this `pub` item is unused"
+)]
+pub(crate) struct UnusedPubItemsInBinaryNote;
+
 #[derive(Subdiagnostic)]
 #[note(
     "it is impossible to refer to the {$dead_descr} `{$dead_name}` because it is shadowed by this enum variant with the same name"

compiler/rustc_span/src/symbol.rs

@@ -2189,6 +2189,7 @@ symbols! {
         unstable_removed,
         untagged_unions,
         unused_imports,
+        unused_pub_items_in_binary,
         unwind,
         unwind_attributes,
         unwind_safe_trait,

tests/ui/lint/unused-pub-items-in-binary/allow-dead-code-transitive.rs

@@ -0,0 +1,14 @@
+#![deny(dead_code)]
+#![deny(unused_pub_items_in_binary)]
+
+pub fn g() {} //~ ERROR function `g` is never used
+
+fn h() {}
+
+#[allow(dead_code)]
+fn f() {
+    g();
+    h();
+}
+
+fn main() {}

tests/ui/lint/unused-pub-items-in-binary/allow-dead-code-transitive.stderr

@@ -0,0 +1,15 @@
+error: function `g` is never used
+  --> $DIR/allow-dead-code-transitive.rs:4:8
+   |
+LL | pub fn g() {}
+   |        ^
+   |
+   = note: in libraries, `pub` items can be used by dependent crates; in binaries, they cannot, so this `pub` item is unused
+note: the lint level is defined here
+  --> $DIR/allow-dead-code-transitive.rs:2:9
+   |
+LL | #![deny(unused_pub_items_in_binary)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

tests/ui/lint/unused-pub-items-in-binary/allow-lint.rs

@@ -0,0 +1,12 @@
+#![deny(dead_code)]
+#![allow(unused_pub_items_in_binary)]
+
+pub fn unused_pub_fn() {
+    helper();
+}
+
+fn helper() {}
+
+fn unused_priv_fn() {} //~ ERROR function `unused_priv_fn` is never used
+
+fn main() {}

tests/ui/lint/unused-pub-items-in-binary/allow-lint.stderr

@@ -0,0 +1,14 @@
+error: function `unused_priv_fn` is never used
+  --> $DIR/allow-lint.rs:10:4
+   |
+LL | fn unused_priv_fn() {}
+   |    ^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/allow-lint.rs:1:9
+   |
+LL | #![deny(dead_code)]
+   |         ^^^^^^^^^
+
+error: aborting due to 1 previous error
+