Lint unused pub items in binary crates

compiler/rustc_lint_defs/src/builtin.rs

@@ -146,6 +146,7 @@ declare_lint_pass! {
         UNUSED_MACROS,
         UNUSED_MACRO_RULES,
         UNUSED_MUT,
+        UNUSED_PUB_ITEMS_IN_BINARY,
         UNUSED_QUALIFICATIONS,
         UNUSED_UNSAFE,
         UNUSED_VARIABLES,
@@ -782,6 +783,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

@@ -0,0 +1,23 @@
+use rustc_data_structures::fx::FxIndexSet;
+use rustc_hir::def_id::{DefId, LocalDefIdMap, LocalDefIdSet};
+use rustc_macros::HashStable;
+
+/// A single snapshot of dead-code liveness analysis state.
+#[derive(Clone, Debug, HashStable)]
+pub struct DeadCodeLivenessSnapshot {
+    pub live_symbols: LocalDefIdSet,
+    /// Maps each ADT to derived traits (for example `Debug` and `Clone`) that should be ignored
+    /// when checking for dead code diagnostics.
+    pub ignored_derived_traits: LocalDefIdMap<FxIndexSet<DefId>>,
+}
+
+/// Dead-code liveness data for both analysis phases.
+///
+/// `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,
+    pub final_result: DeadCodeLivenessSnapshot,
+}

compiler/rustc_middle/src/middle/mod.rs

@@ -1,4 +1,5 @@
 pub mod codegen_fn_attrs;
+pub mod dead_code;
 pub mod debugger_visualizer;
 pub mod deduced_param_attrs;
 pub mod dependency_format;

compiler/rustc_middle/src/queries.rs

@@ -64,9 +64,7 @@ use rustc_errors::{ErrorGuaranteed, catch_fatal_errors};
 use rustc_hir as hir;
 use rustc_hir::attrs::{EiiDecl, EiiImpl, StrippedCfgItem};
 use rustc_hir::def::{DefKind, DocLinkResMap};
-use rustc_hir::def_id::{
-    CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap, LocalDefIdSet, LocalModDefId,
-};
+use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdSet, LocalModDefId};
 use rustc_hir::lang_items::{LangItem, LanguageItems};
 use rustc_hir::{ItemLocalId, ItemLocalMap, PreciseCapturingArgKind, TraitCandidate};
 use rustc_index::IndexVec;
@@ -87,6 +85,7 @@ use crate::infer::canonical::{self, Canonical};
 use crate::lint::LintExpectation;
 use crate::metadata::ModChild;
 use crate::middle::codegen_fn_attrs::{CodegenFnAttrs, SanitizerFnAttrs};
+use crate::middle::dead_code::DeadCodeLivenessSummary;
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
 use crate::middle::deduced_param_attrs::DeducedParamAttrs;
 use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
@@ -1199,13 +1198,8 @@ rustc_queries! {
         desc { "checking liveness of variables in `{}`", tcx.def_path_str(key.to_def_id()) }
     }
 
-    /// Return the live symbols in the crate for dead code check.
-    ///
-    /// The second return value maps from ADTs to ignored derived traits (e.g. Debug and Clone).
-    query live_symbols_and_ignored_derived_traits(_: ()) -> Result<&'tcx (
-        LocalDefIdSet,
-        LocalDefIdMap<FxIndexSet<DefId>>,
-    ), ErrorGuaranteed> {
+    /// Return dead-code liveness summary for the crate.
+    query live_symbols_and_ignored_derived_traits(_: ()) -> Result<&'tcx DeadCodeLivenessSummary, ErrorGuaranteed> {
         arena_cache
         desc { "finding live symbols in crate" }
     }

compiler/rustc_passes/src/check_attr.rs

@@ -1682,6 +1682,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 {