Fix ICE when Self is used in enum discriminant of a generic enum

Move the validation into the existing `check_param_uses_if_mcg` machinery
in HIR ty lowering instead of adding a new check in wfcheck. After #150519
introduced `AnonConstKind`, `ForbidMCGParamUsesFolder` was only gated on
`AnonConstKind::MCG`, causing discriminant anon consts (`NonTypeSystem`) to
bypass it entirely.

Add `anon_const_forbids_generic_params()` which returns the appropriate
`ForbidParamContext` for both MCG and enum discriminant contexts. Wire it
into `check_param_uses_if_mcg` so that `Self` aliasing a generic type is
caught before reaching `const_eval_poly`. Convert the `TooGeneric` span_bug
into a proper diagnostic as a fallback for anything slipping through
type-dependent path resolution.

Author: GokhanKabar

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1107,27 +1107,17 @@ fn check_type_defn<'tcx>(
 
             // Explicit `enum` discriminant values must const-evaluate successfully.
             if let ty::VariantDiscr::Explicit(discr_def_id) = variant.discr {
-                // Reject discriminants that use `Self` when the enum has
-                // type or const generic parameters, since `Self` resolves
-                // to the enum type including those parameters.
-                if let Some(local_id) = discr_def_id.as_local()
-                    && enum_has_type_or_const_generics(tcx, item.owner_id.def_id)
-                    && discr_body_references_self(tcx, local_id)
-                {
-                    tcx.dcx().span_err(
-                        tcx.def_span(discr_def_id),
-                        "generic parameters may not be used in enum discriminant values",
-                    );
-                } else {
-                    match tcx.const_eval_poly(discr_def_id) {
-                        Ok(_) => {}
-                        Err(ErrorHandled::Reported(..)) => {}
-                        Err(ErrorHandled::TooGeneric(_)) => {
-                            tcx.dcx().span_err(
-                                tcx.def_span(discr_def_id),
-                                "enum discriminant value depends on generic parameters",
-                            );
-                        }
+                match tcx.const_eval_poly(discr_def_id) {
+                    Ok(_) => {}
+                    Err(ErrorHandled::Reported(..)) => {}
+                    Err(ErrorHandled::TooGeneric(_)) => {
+                        // This can happen if a discriminant slips past the checks in HIR ty
+                        // lowering (e.g. via type-dependent path resolution). Emit a proper
+                        // error rather than ICE-ing.
+                        tcx.dcx().span_err(
+                            tcx.def_span(discr_def_id),
+                            "enum discriminant value depends on generic parameters",
+                        );
                     }
                 }
             }
@@ -1138,31 +1128,6 @@ fn check_type_defn<'tcx>(
     })
 }
 
-fn enum_has_type_or_const_generics(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-    tcx.generics_of(def_id).own_params.iter().any(|p| {
-        matches!(
-            p.kind,
-            ty::GenericParamDefKind::Type { .. } | ty::GenericParamDefKind::Const { .. }
-        )
-    })
-}
-
-fn discr_body_references_self(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-    struct SelfRefVisitor(bool);
-    impl<'hir> intravisit::Visitor<'hir> for SelfRefVisitor {
-        fn visit_path(&mut self, path: &hir::Path<'hir>, _: hir::HirId) {
-            if matches!(path.res, Res::SelfTyAlias { .. }) {
-                self.0 = true;
-            }
-            intravisit::walk_path(self, path);
-        }
-    }
-    let body = tcx.hir_body_owned_by(def_id);
-    let mut visitor = SelfRefVisitor(false);
-    intravisit::walk_body(&mut visitor, body);
-    visitor.0
-}
-
 #[instrument(skip(tcx, item))]
 fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) -> Result<(), ErrorGuaranteed> {
     debug!(?item.owner_id);

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -163,11 +163,9 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
                 }
                 ty::AnonConstKind::GCE => Some(parent_did),
 
+                // Field defaults are allowed to use generic parameters, e.g. `field: u32 = /*defid: N + 1*/`
                 ty::AnonConstKind::NonTypeSystem
-                    if matches!(
-                        tcx.parent_hir_node(hir_id),
-                        Node::TyPat(_) | Node::Field(_) | Node::Variant(_)
-                    ) =>
+                    if matches!(tcx.parent_hir_node(hir_id), Node::TyPat(_) | Node::Field(_)) =>
                 {
                     Some(parent_did)
                 }

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -376,24 +376,41 @@ pub trait GenericArgsLowerer<'a, 'tcx> {
     ) -> ty::GenericArg<'tcx>;
 }
 
+/// Context in which `ForbidMCGParamUsesFolder` is being used, to emit appropriate diagnostics.
+enum ForbidParamContext {
+    /// Anon const in a min-const-generics (MCG) position, e.g. a const argument.
+    MinConstGenerics,
+    /// Enum discriminant expression.
+    EnumDiscriminant,
+}
+
 struct ForbidMCGParamUsesFolder<'tcx> {
     tcx: TyCtxt<'tcx>,
     anon_const_def_id: LocalDefId,
     span: Span,
     is_self_alias: bool,
+    context: ForbidParamContext,
 }
 
 impl<'tcx> ForbidMCGParamUsesFolder<'tcx> {
     fn error(&self) -> ErrorGuaranteed {
-        let msg = if self.is_self_alias {
-            "generic `Self` types are currently not permitted in anonymous constants"
-        } else if self.tcx.features().opaque_generic_const_args() {
-            "generic parameters in const blocks are only allowed as the direct value of a `type const`"
-        } else {
-            "generic parameters may not be used in const operations"
+        let msg = match self.context {
+            ForbidParamContext::EnumDiscriminant if self.is_self_alias =>
+                "generic `Self` types are not permitted in enum discriminant values",
+            ForbidParamContext::EnumDiscriminant =>
+                "generic parameters may not be used in enum discriminant values",
+            ForbidParamContext::MinConstGenerics if self.is_self_alias =>
+                "generic `Self` types are currently not permitted in anonymous constants",
+            ForbidParamContext::MinConstGenerics => {
+                if self.tcx.features().opaque_generic_const_args() {
+                    "generic parameters in const blocks are only allowed as the direct value of a `type const`"
+                } else {
+                    "generic parameters may not be used in const operations"
+                }
+            }
         };
         let mut diag = self.tcx.dcx().struct_span_err(self.span, msg);
-        if self.is_self_alias {
+        if self.is_self_alias && matches!(self.context, ForbidParamContext::MinConstGenerics) {
             let anon_const_hir_id: HirId = HirId::make_owner(self.anon_const_def_id);
             let parent_impl = self.tcx.hir_parent_owner_iter(anon_const_hir_id).find_map(
                 |(_, node)| match node {
@@ -407,13 +424,15 @@ impl<'tcx> ForbidMCGParamUsesFolder<'tcx> {
                 diag.span_note(impl_.self_ty.span, "not a concrete type");
             }
         }
-        if self.tcx.features().min_generic_const_args() {
+        if matches!(self.context, ForbidParamContext::MinConstGenerics)
+            && self.tcx.features().min_generic_const_args()
+        {
             if !self.tcx.features().opaque_generic_const_args() {
                 diag.help("add `#![feature(opaque_generic_const_args)]` to allow generic expressions as the RHS of const items");
             } else {
                 diag.help("consider factoring the expression into a `type const` item and use it as the const argument instead");
             }
-        };
+        }
         diag.emit()
     }
 }
@@ -465,32 +484,56 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 anon_const_def_id: parent_def_id,
                 span,
                 is_self_alias: false,
+                context: ForbidParamContext::MinConstGenerics,
             };
             return Err(folder.error());
         }
         Ok(())
     }
 
+    /// Returns the `ForbidParamContext` for the current anon const if it is a context that
+    /// forbids uses of generic parameters that escape through type-dependent paths (e.g. `Self`
+    /// aliasing a generic type), or `None` if the current item is not such a context.
+    ///
+    /// Name resolution handles most invalid generic parameter uses in these contexts, but it
+    /// cannot reject `Self` that aliases a generic type, nor generic parameters introduced by
+    /// type-dependent name resolution (e.g. `<Self as Trait>::Assoc` resolving to a type that
+    /// contains params). Those cases are handled by `check_param_uses_if_mcg`.
+    fn anon_const_forbids_generic_params(&self) -> Option<ForbidParamContext> {
+        let tcx = self.tcx();
+        let parent_def_id = self.item_def_id();
+        if tcx.def_kind(parent_def_id) != DefKind::AnonConst {
+            return None;
+        }
+        match tcx.anon_const_kind(parent_def_id) {
+            ty::AnonConstKind::MCG => Some(ForbidParamContext::MinConstGenerics),
+            ty::AnonConstKind::NonTypeSystem => {
+                let hir_id = tcx.local_def_id_to_hir_id(parent_def_id);
+                matches!(tcx.parent_hir_node(hir_id), hir::Node::Variant(_))
+                    .then_some(ForbidParamContext::EnumDiscriminant)
+            }
+            _ => None,
+        }
+    }
+
     /// Check for uses of generic parameters that are not in scope due to this being
-    /// in a non-generic anon const context.
+    /// in a non-generic anon const context (e.g. MCG or an enum discriminant).
+    ///
+    /// Name resolution rejects most invalid uses, but cannot handle `Self` aliasing a
+    /// generic type or generic parameters introduced by type-dependent name resolution.
     #[must_use = "need to use transformed output"]
     fn check_param_uses_if_mcg<T>(&self, term: T, span: Span, is_self_alias: bool) -> T
     where
         T: ty::TypeFoldable<TyCtxt<'tcx>>,
     {
         let tcx = self.tcx();
-        let parent_def_id = self.item_def_id();
-        if tcx.def_kind(parent_def_id) == DefKind::AnonConst
-            && let ty::AnonConstKind::MCG = tcx.anon_const_kind(parent_def_id)
+        let anon_const_def_id = self.item_def_id();
+        if let Some(context) = self.anon_const_forbids_generic_params()
             // Fast path if contains no params/escaping bound vars.
             && (term.has_param() || term.has_escaping_bound_vars())
         {
-            let mut folder = ForbidMCGParamUsesFolder {
-                tcx,
-                anon_const_def_id: parent_def_id,
-                span,
-                is_self_alias,
-            };
+            let mut folder =
+                ForbidMCGParamUsesFolder { tcx, anon_const_def_id, span, is_self_alias, context };
             term.fold_with(&mut folder)
         } else {
             term

tests/ui/enum-discriminant/generic-self-in-discr-ice.rs

@@ -5,7 +5,7 @@ use std::marker::PointeeSized;
 #[repr(usize)]
 enum What<T: PointeeSized> {
     X = size_of::<*mut Self>(),
-    //~^ ERROR generic parameters may not be used in enum discriminant values
+    //~^ ERROR generic `Self` types are not permitted in enum discriminant values
     Y(*mut T),
 }
 

tests/ui/enum-discriminant/generic-self-in-discr-ice.stderr

@@ -1,8 +1,8 @@
-error: generic parameters may not be used in enum discriminant values
-  --> $DIR/generic-self-in-discr-ice.rs:7:9
+error: generic `Self` types are not permitted in enum discriminant values
+  --> $DIR/generic-self-in-discr-ice.rs:7:24
    |
 LL |     X = size_of::<*mut Self>(),
-   |         ^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^^^
 
 error: aborting due to 1 previous error