Make traits / trait methods detected by the dead code lint

Author: mu001999

compiler/rustc_passes/src/dead.rs

@@ -4,6 +4,7 @@
 // is dead.
 
 use hir::def_id::{LocalDefIdMap, LocalDefIdSet};
+use hir::AssocItemKind;
 use itertools::Itertools;
 use rustc_data_structures::unord::UnordSet;
 use rustc_errors::MultiSpan;
@@ -379,6 +380,17 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
                 _ => intravisit::walk_item(self, item),
             },
             Node::TraitItem(trait_item) => {
+                // FIXME: could we get all impl terms for the trait item?
+                // then we can add them into worklist when the trait item is live,
+                // so that we won't lose any lost chain in the impl terms.
+                // this also allows us to lint such code:
+                // ```rust
+                // struct UnusedStruct; //~ WARN
+                // trait UnusedTrait { //~ WARN
+                //     fn foo() {}
+                // }
+                // impl UnusedTrait for UnusedStruct { fn foo() {} }
+                // ```
                 intravisit::walk_trait_item(self, trait_item);
             }
             Node::ImplItem(impl_item) => {
@@ -627,7 +639,20 @@ fn check_item<'tcx>(
             }
         }
         DefKind::Impl { of_trait } => {
-            if of_trait {
+            // lints unused struct and traits after 2024, e.g.,
+            // ```rust
+            // #[derive(Debug)]
+            // struct Unused; //~ WARN
+            //
+            // trait Foo {} //~ WARN
+            // impl Foo for () {}
+            // ```
+            // but we still cannot lint unused traits whose impl blocks have methods:
+            // ```rust
+            // trait Foo { fn foo(); }
+            // impl Foo for () { fn foo() {} }
+            // ```
+            if of_trait && !tcx.hir().item(id).span.source_callsite().at_least_rust_2024() {
                 worklist.push((id.owner_id.def_id, ComesFromAllowExpect::No));
             }
 
@@ -640,6 +665,8 @@ fn check_item<'tcx>(
             // And we access the Map here to get HirId from LocalDefId
             for id in local_def_ids {
                 if of_trait {
+                    // FIXME: not push impl item into worklist by default,
+                    // pushed when corresponding trait items are reachable.
                     worklist.push((id, ComesFromAllowExpect::No));
                 } else if let Some(comes_from_allow) = has_allow_dead_code_or_lang_attr(tcx, id) {
                     worklist.push((id, comes_from_allow));
@@ -939,6 +966,13 @@ impl<'tcx> DeadVisitor<'tcx> {
             | DefKind::Enum
             | DefKind::Union
             | DefKind::ForeignTy => self.warn_dead_code(def_id, "used"),
+            DefKind::Trait => {
+                if let Some(Node::Item(item)) = self.tcx.hir().find_by_def_id(def_id)
+                    && item.span.at_least_rust_2024()
+                {
+                    self.warn_dead_code(def_id, "used")
+                }
+            }
             DefKind::Struct => self.warn_dead_code(def_id, "constructed"),
             DefKind::Variant | DefKind::Field => bug!("should be handled specially"),
             _ => {}
@@ -967,7 +1001,24 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalModDefId) {
             let mut dead_items = Vec::new();
             for item in impl_item.items {
                 let def_id = item.id.owner_id.def_id;
-                if !visitor.is_live_code(def_id) {
+                let is_dead_code = if !visitor.is_live_code(def_id) {
+                    true
+                } else if item.span.edition().at_least_rust_2024() // temporary
+                    && let AssocItemKind::Fn { .. } = item.kind
+                    && let Some(local_def_id) = item.trait_item_def_id.and_then(DefId::as_local)
+                    && !visitor.is_live_code(local_def_id)
+                    && has_allow_dead_code_or_lang_attr(tcx, local_def_id).is_none()
+                {
+                    // lint methods in impl if we are sure the corresponding methods in trait are dead,
+                    // but the chain of dead code within the methods in impl would be lost.
+
+                    // FIXME: the better way is to mark trait items and corresponding impl items active,
+                    // then the rests are dead, which requires the above FIXME at line 383
+                    true
+                } else {
+                    false
+                };
+                if is_dead_code {
                     let name = tcx.item_name(def_id.to_def_id());
                     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
                     let level = tcx.lint_level_at_node(lint::builtin::DEAD_CODE, hir_id).0;
@@ -1041,7 +1092,11 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalModDefId) {
         visitor.check_definition(foreign_item.owner_id.def_id);
     }
 
-    // We do not warn trait items.
+    for trait_item in module_items.trait_items() {
+        if tcx.hir().trait_item(trait_item).span.at_least_rust_2024() {
+            visitor.check_definition(trait_item.owner_id.def_id);
+        }
+    }
 }
 
 pub(crate) fn provide(providers: &mut Providers) {

tests/ui/lint/dead-code/issue-41883.rs

@@ -0,0 +1,33 @@
+// edition: 2024
+// compile-flags: -Zunstable-options
+#![deny(dead_code)]
+
+enum Category {
+    Dead, //~ ERROR variant `Dead` is never constructed
+    Used,
+}
+
+trait Demo {
+    fn this_is_unused(&self) -> Category { //~ ERROR method `this_is_unused` is never used
+        Category::Dead
+    }
+}
+
+impl Demo for () {
+    fn this_is_unused(&self) -> Category { //~ ERROR method `this_is_unused` is never used
+        Category::Used
+    }
+}
+
+impl UnusedTrait for () {}
+
+trait UnusedTrait {} //~ ERROR trait `UnusedTrait` is never used
+
+mod private {
+    #[derive(Debug)]
+    struct UnusedStruct; //~ ERROR struct `UnusedStruct` is never constructed
+}
+
+fn main() {
+    let _c = Category::Used;
+}

tests/ui/lint/dead-code/issue-41883.stderr

@@ -0,0 +1,44 @@
+error: variant `Dead` is never constructed
+  --> $DIR/issue-41883.rs:6:5
+   |
+LL | enum Category {
+   |      -------- variant in this enum
+LL |     Dead,
+   |     ^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/issue-41883.rs:3:9
+   |
+LL | #![deny(dead_code)]
+   |         ^^^^^^^^^
+
+error: method `this_is_unused` is never used
+  --> $DIR/issue-41883.rs:17:8
+   |
+LL | impl Demo for () {
+   | ---------------- method in this implementation
+LL |     fn this_is_unused(&self) -> Category {
+   |        ^^^^^^^^^^^^^^
+
+error: trait `UnusedTrait` is never used
+  --> $DIR/issue-41883.rs:24:7
+   |
+LL | trait UnusedTrait {}
+   |       ^^^^^^^^^^^
+
+error: method `this_is_unused` is never used
+  --> $DIR/issue-41883.rs:11:8
+   |
+LL |     fn this_is_unused(&self) -> Category {
+   |        ^^^^^^^^^^^^^^
+
+error: struct `UnusedStruct` is never constructed
+  --> $DIR/issue-41883.rs:28:12
+   |
+LL |     struct UnusedStruct;
+   |            ^^^^^^^^^^^^
+   |
+   = note: `UnusedStruct` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
+
+error: aborting due to 5 previous errors
+