Add regression tests for fixed dead-code issues

tests/ui/lint/dead-code/allow-derived-inherent-impl-issue-102190.rs

@@ -0,0 +1,19 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/102190>
+
+//@ check-pass
+//@ proc-macro: generate-inherent-impl-with-input-spans.rs
+
+#![deny(dead_code)]
+
+extern crate generate_inherent_impl_with_input_spans;
+
+use generate_inherent_impl_with_input_spans::Test;
+
+#[allow(dead_code)]
+#[derive(Test)]
+#[repr(i8)]
+pub(crate) enum MyEnum {
+    MyValue,
+}
+
+fn main() {}

tests/ui/lint/dead-code/auxiliary/generate-inherent-impl-with-input-spans.rs

@@ -0,0 +1,35 @@
+extern crate proc_macro;
+
+use proc_macro::{Delimiter, Group, Ident, TokenStream, TokenTree};
+
+#[proc_macro_derive(Test)]
+pub fn derive(input: TokenStream) -> TokenStream {
+    let input = input.into_iter().collect::<Vec<_>>();
+    let input_span = input[0].span();
+
+    let output = "impl MyEnum {
+        pub(crate) fn false_positive(self) -> i8 {
+            self as i8
+        }
+    }"
+    .parse::<TokenStream>()
+    .unwrap()
+    .into_iter()
+    .collect::<Vec<_>>();
+
+    let TokenTree::Group(body) = &output[2] else { unreachable!() };
+    let mut body = body.stream().into_iter().collect::<Vec<_>>();
+
+    // Preserve the visibility tokens from the input, as `quote!` does when interpolating `#vis`.
+    body[0] = input[0].clone();
+    body[1] = input[1].clone();
+
+    // Give the return type the input's span, matching `Ident::new("i8", input.span())`.
+    body[7] = TokenTree::Ident(Ident::new("i8", input_span));
+
+    let mut generated_body =
+        Group::new(Delimiter::Brace, body.into_iter().collect::<TokenStream>());
+    generated_body.set_span(output[2].span());
+
+    vec![output[0].clone(), output[1].clone(), generated_body.into()].into_iter().collect()
+}

tests/ui/lint/dead-code/expect-on-assoc-fn-issue-148861.rs

@@ -0,0 +1,25 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/148861>
+
+//@ check-pass
+
+#![deny(dead_code)]
+
+use std::any::Any;
+
+pub trait Foo: Any {}
+
+impl Foo for Box<dyn Foo> {}
+
+impl dyn Foo {
+    #[expect(dead_code)]
+    fn downcast_ref<T: 'static>(&self) -> Option<&T> {
+        let this = self as &dyn Any;
+        if let Some(boxed) = this.downcast_ref::<Box<dyn Foo>>() {
+            boxed.downcast_ref::<T>()
+        } else {
+            this.downcast_ref::<T>()
+        }
+    }
+}
+
+fn main() {}

tests/ui/lint/dead-code/struct-used-as-pattern-issue-56750.rs

@@ -0,0 +1,17 @@
+//! Regression test for <https://github.com/rust-lang/rust/issues/56750>
+
+//@ check-pass
+
+#![deny(dead_code)]
+
+use std::mem;
+
+fn main() {
+    struct Value {
+        a: i32,
+        b: i32,
+    }
+
+    let Value { a, b } = unsafe { mem::zeroed() };
+    println!("{a} {b}");
+}