Fix multiple expect attribs in impl block

compiler/rustc_passes/src/dead.rs

@@ -1,4 +1,4 @@
-// This implements the dead-code warning pass. It follows middle::reachable
+// This implements the dead-code warning pass. It follows crate::reachable
 // closely. The idea is that all reachable symbols are live, codes called
 // from live codes are live, and everything else is dead.
 
@@ -723,6 +723,12 @@ impl<'tcx> DeadVisitor<'tcx> {
         ShouldWarnAboutField::Yes(is_positional)
     }
 
+    // # 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
+    // first local def id.
+    // Prefer calling `Self.warn_dead_code` or `Self.warn_dead_code_grouped_by_lint_level`
+    // since those methods group by lint level before calling this method.
     fn warn_multiple_dead_codes(
         &self,
         dead_codes: &[LocalDefId],
@@ -734,6 +740,15 @@ impl<'tcx> DeadVisitor<'tcx> {
             return;
         };
         let tcx = self.tcx;
+
+        let first_hir_id = tcx.hir().local_def_id_to_hir_id(first_id);
+        let first_lint_level = tcx.lint_level_at_node(lint::builtin::DEAD_CODE, first_hir_id).0;
+        assert!(dead_codes.iter().skip(1).all(|id| {
+            let hir_id = tcx.hir().local_def_id_to_hir_id(*id);
+            let level = tcx.lint_level_at_node(lint::builtin::DEAD_CODE, hir_id).0;
+            level == first_lint_level
+        }));
+
         let names: Vec<_> =
             dead_codes.iter().map(|&def_id| tcx.item_name(def_id.to_def_id())).collect();
         let spans: Vec<_> = dead_codes
@@ -816,13 +831,13 @@ impl<'tcx> DeadVisitor<'tcx> {
 
         self.tcx.emit_spanned_lint(
             lint,
-            tcx.hir().local_def_id_to_hir_id(first_id),
+            first_hir_id,
             MultiSpan::from_spans(spans),
             diag,
         );
     }
 
-    fn warn_dead_fields_and_variants(
+    fn warn_dead_code_grouped_by_lint_level(
         &self,
         def_id: LocalDefId,
         participle: &str,
@@ -894,15 +909,23 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalDefId) {
         if let hir::ItemKind::Impl(impl_item) = tcx.hir().item(item).kind {
             let mut dead_items = Vec::new();
             for item in impl_item.items {
-                let did = item.id.owner_id.def_id;
-                if !visitor.is_live_code(did) {
-                    dead_items.push(did)
+                let def_id = item.id.owner_id.def_id;
+                if !visitor.is_live_code(def_id) {
+                    let name = tcx.item_name(def_id.to_def_id());
+                    let hir = tcx.hir().local_def_id_to_hir_id(def_id);
+                    let level = tcx.lint_level_at_node(lint::builtin::DEAD_CODE, hir).0;
+
+                    dead_items.push(DeadVariant {
+                        def_id,
+                        name,
+                        level,
+                    })
                 }
             }
-            visitor.warn_multiple_dead_codes(
-                &dead_items,
+            visitor.warn_dead_code_grouped_by_lint_level(
+                item.owner_id.def_id,
                 "used",
-                Some(item.owner_id.def_id),
+                dead_items,
                 false,
             );
         }
@@ -959,10 +982,10 @@ fn check_mod_deathness(tcx: TyCtxt<'_>, module: LocalDefId) {
                         }
                     })
                     .collect();
-                visitor.warn_dead_fields_and_variants(def_id, "read", dead_fields, is_positional)
+                visitor.warn_dead_code_grouped_by_lint_level(def_id, "read", dead_fields, is_positional)
             }
 
-            visitor.warn_dead_fields_and_variants(
+            visitor.warn_dead_code_grouped_by_lint_level(
                 item.owner_id.def_id,
                 "constructed",
                 dead_variants,

tests/incremental/issue-114416-expect-unused-inside-impl-block.rs

@@ -0,0 +1,32 @@
+// revisions: rpass1
+//
+// The corresponding ui test can be found in
+// `tests/ui/lint/rfc-2383-lint-reason/expect_unused_inside_impl_block.rs`
+
+#![feature(lint_reasons)]
+#![warn(unused)]
+
+struct OneUnused;
+struct TwoUnused;
+
+impl OneUnused {
+    #[expect(unused)]
+    fn unused() {}
+}
+
+impl TwoUnused {
+    #[expect(unused)]
+    fn unused1(){}
+
+    // This unused method has `#[expect(unused)]`, so the compiler should not emit a warning.
+    // This ui test was added after a regression in the compiler where it did not recognize multiple
+    // `#[expect(unused)]` annotations inside of impl blocks.
+    // issue 114416
+    #[expect(unused)]
+    fn unused2(){}
+}
+
+fn main() {
+    let _ = OneUnused;
+    let _ = TwoUnused;
+}

tests/ui/lint/rfc-2383-lint-reason/expect_unused_inside_impl_block.rs

@@ -0,0 +1,32 @@
+// check-pass
+//
+// The corresponding incremental compilation test can be found in
+// `tests/incremental/issue-114416-expect-unused-inside-impl-block.rs`
+
+#![feature(lint_reasons)]
+#![warn(unused)]
+
+struct OneUnused;
+struct TwoUnused;
+
+impl OneUnused {
+    #[expect(unused)]
+    fn unused() {}
+}
+
+impl TwoUnused {
+    #[expect(unused)]
+    fn unused1(){}
+
+    // This unused method has `#[expect(unused)]`, so the compiler should not emit a warning.
+    // This ui test was added after a regression in the compiler where it did not recognize multiple
+    // `#[expect(unused)]` annotations inside of impl blocks.
+    // issue 114416
+    #[expect(unused)]
+    fn unused2(){}
+}
+
+fn main() {
+    let _ = OneUnused;
+    let _ = TwoUnused;
+}