detect when variants have the same name as an associated function

Author: jdonszelmann

compiler/rustc_passes/messages.ftl

@@ -290,6 +290,9 @@ passes_duplicate_lang_item_crate_depends =
     .first_definition_path = first definition in `{$orig_crate_name}` loaded from {$orig_path}
     .second_definition_path = second definition in `{$crate_name}` loaded from {$path}
 
+passes_enum_variant_same_name =
+    it is impossible to call the function because it is shadowed by this enum variant with the same name
+
 passes_export_name =
     attribute should be applied to a free function, impl method or static
     .label = not a free function, impl method or static

compiler/rustc_passes/src/dead.rs

@@ -14,7 +14,7 @@ use rustc_errors::MultiSpan;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{self as hir, Node, PatKind, QPath, TyKind};
+use rustc_hir::{self as hir, ImplItem, ImplItemKind, Node, PatKind, QPath, TyKind};
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::middle::privacy::Level;
 use rustc_middle::query::Providers;
@@ -936,7 +936,9 @@ enum ShouldWarnAboutField {
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum ReportOn {
+    /// Report on something that hasn't got a proper name to refer to
     TupleField,
+    /// Report on something that has got a name, which could be a field but also a method
     NamedField,
 }
 
@@ -1061,6 +1063,23 @@ impl<'tcx> DeadVisitor<'tcx> {
                 None
             };
 
+        let enum_variant_with_same_name =
+            if let Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(..), .. }) =
+                tcx.hir_node_by_def_id(first_item.def_id)
+                && let Some(impl_did) = tcx.opt_parent(first_item.def_id.to_def_id())
+                && let DefKind::Impl { of_trait: false } = tcx.def_kind(impl_did)
+                && let ty::Adt(maybe_enum, _) = tcx.type_of(impl_did).skip_binder().kind()
+                && maybe_enum.is_enum()
+                && let Some(variant) =
+                    maybe_enum.variants().iter().find(|i| i.name == first_item.name)
+            {
+                Some(crate::errors::EnumVariantSameName {
+                    variant_span: tcx.def_span(variant.def_id),
+                })
+            } else {
+                None
+            };
+
         let diag = match report_on {
             ReportOn::TupleField => {
                 let tuple_fields = if let Some(parent_id) = parent_item
@@ -1114,6 +1133,7 @@ impl<'tcx> DeadVisitor<'tcx> {
                 name_list,
                 parent_info,
                 ignored_derived_impls,
+                enum_variant_with_same_name,
             },
         };
 

compiler/rustc_passes/src/errors.rs

@@ -1478,6 +1478,9 @@ pub(crate) enum MultipleDeadCodes<'tcx> {
         participle: &'tcx str,
         name_list: DiagSymbolList,
         #[subdiagnostic]
+        // only on DeadCodes since it's never a problem for tuple struct fields
+        enum_variant_with_same_name: Option<EnumVariantSameName>,
+        #[subdiagnostic]
         parent_info: Option<ParentInfo<'tcx>>,
         #[subdiagnostic]
         ignored_derived_impls: Option<IgnoredDerivedImpls>,
@@ -1498,6 +1501,13 @@ pub(crate) enum MultipleDeadCodes<'tcx> {
     },
 }
 
+#[derive(Subdiagnostic)]
+#[note(passes_enum_variant_same_name)]
+pub(crate) struct EnumVariantSameName {
+    #[primary_span]
+    pub variant_span: Span,
+}
+
 #[derive(Subdiagnostic)]
 #[label(passes_parent_info)]
 pub(crate) struct ParentInfo<'tcx> {

tests/ui/enum/dead-code-associated-function.stderr

@@ -7,6 +7,11 @@ LL |     #[expect(non_snake_case)]
 LL |     fn V() {}
    |        ^
    |
+note: it is impossible to call the function because it is shadowed by this enum variant with the same name
+  --> $DIR/dead-code-associated-function.rs:5:5
+   |
+LL |     V(),
+   |     ^
 note: the lint level is defined here
   --> $DIR/dead-code-associated-function.rs:2:9
    |