Improve handling of item bodies in generics_of

Author: camelid

compiler/rustc_hir_analysis/src/collect.rs

@@ -1527,14 +1527,27 @@ fn anon_const_kind<'tcx>(tcx: TyCtxt<'tcx>, def: LocalDefId) -> ty::AnonConstKin
     let const_arg_id = tcx.parent_hir_id(hir_id);
     match tcx.hir_node(const_arg_id) {
         hir::Node::ConstArg(_) => {
-            if tcx.features().generic_const_exprs() {
+            let parent_hir_node = tcx.hir_node(tcx.parent_hir_id(const_arg_id));
+            if let hir::Node::Item(hir::Item { kind: hir::ItemKind::Const(.., body), .. })
+            | hir::Node::TraitItem(hir::TraitItem {
+                kind: hir::TraitItemKind::Const(.., Some(body)),
+                ..
+            })
+            | hir::Node::ImplItem(hir::ImplItem {
+                kind: hir::ImplItemKind::Const(.., body),
+                ..
+            }) = parent_hir_node
+                && body.hir_id == const_arg_id
+            {
+                return ty::AnonConstKind::ItemBody;
+            } else if tcx.features().generic_const_exprs() {
                 ty::AnonConstKind::GCE
             } else if tcx.features().min_generic_const_args() {
                 ty::AnonConstKind::MCG
             } else if let hir::Node::Expr(hir::Expr {
                 kind: hir::ExprKind::Repeat(_, repeat_count),
                 ..
-            }) = tcx.hir_node(tcx.parent_hir_id(const_arg_id))
+            }) = parent_hir_node
                 && repeat_count.hir_id == const_arg_id
             {
                 ty::AnonConstKind::RepeatExprCount

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -77,21 +77,6 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
         // stable enough and does not need a feature gate anymore.
         Node::AnonConst(_) => {
             let parent_did = tcx.parent(def_id.to_def_id());
-
-            // We don't do this unconditionally because the `DefId` parent of an anon const
-            // might be an implicitly created closure during `async fn` desugaring. This would
-            // have the wrong generics.
-            //
-            // i.e. `async fn foo<'a>() { let a = [(); { 1 + 2 }]; bar().await() }`
-            // would implicitly have a closure in its body that would be the parent of
-            // the `{ 1 + 2 }` anon const. This closure's generics is simply a witness
-            // instead of `['a]`.
-            let parent_def_kind = tcx.def_kind(parent_did);
-            let parent_did = if let DefKind::AnonConst = parent_def_kind {
-                parent_did
-            } else {
-                tcx.hir_get_parent_item(hir_id).to_def_id()
-            };
             debug!(?parent_did);
 
             let mut in_param_ty = false;
@@ -107,11 +92,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
             match tcx.anon_const_kind(def_id) {
                 // Stable: the RHS of a const item is desugared to be either a const path or an anon const.
                 // If it's an anon const, it should inherit the const item's generics.
-                ty::AnonConstKind::MCG
-                    if matches!(parent_def_kind, DefKind::Const | DefKind::AssocConst) =>
-                {
-                    Some(parent_did)
-                }
+                ty::AnonConstKind::ItemBody => Some(parent_did),
                 // Stable: anon consts are not able to use any generic parameters...
                 ty::AnonConstKind::MCG => None,
                 // we provide generics to repeat expr counts as a backwards compatibility hack. #76200

compiler/rustc_middle/src/mir/interpret/queries.rs

@@ -134,6 +134,7 @@ impl<'tcx> TyCtxt<'tcx> {
                 // If we don't *only* FCW anon consts we can wind up incorrectly FCW'ing uses of assoc
                 // consts in pattern positions. #140447
                 && self.def_kind(cid.instance.def_id()) == DefKind::AnonConst
+                && self.anon_const_kind(cid.instance.def_id()) == ty::AnonConstKind::RepeatExprCount
             {
                 let mir_body = self.mir_for_ctfe(cid.instance.def_id());
                 if mir_body.is_polymorphic {

compiler/rustc_middle/src/ty/consts.rs

@@ -287,6 +287,12 @@ pub enum AnonConstKind {
     GCE,
     /// stable `min_const_generics` anon consts are not allowed to use any generic parameters
     MCG,
+    /// We sometimes use anon consts for the bodies of free and associated const items,
+    /// and they should be handled differently from anon consts used in repeat exprs and const args.
+    ///
+    /// The bodies are allowed to use generics from the parent, whereas anon consts in the type
+    /// of the const item have more restrictions.
+    ItemBody,
     /// anon consts used as the length of a repeat expr are syntactically allowed to use generic parameters
     /// but must not depend on the actual instantiation. See #76200 for more information
     RepeatExprCount,