always lower anon consts for bodies of const items to anon consts on stable

BoxyUwU · BoxyUwU · commit 6a6b0f12ae3f · 2025-09-28T22:31:41.000+01:00
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -201,7 +201,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     |this| {
                         let ty = this
                             .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
-                        let body = this.lower_anon_const_to_const_arg(body.as_deref().unwrap());
+                        let body = this.lower_anon_const_to_const_arg(
+                            body.as_deref().unwrap(),
+                            !this.tcx.features().min_generic_const_args(),
+                        );
                         (ty, body)
                     },
                 );
@@ -812,8 +815,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     |this| {
                         let ty = this
                             .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
-                        let body =
-                            body.as_deref().map(|body| this.lower_anon_const_to_const_arg(body));
+                        let body = body.as_deref().map(|body| {
+                            this.lower_anon_const_to_const_arg(
+                                body,
+                                !this.tcx.features().min_generic_const_args(),
+                            )
+                        });
                         hir::TraitItemKind::Const(ty, body)
                     },
                 );
@@ -1027,7 +1034,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         let ty = this
                             .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
                         this.lower_define_opaque(hir_id, &define_opaque);
-                        let body = this.lower_anon_const_to_const_arg(body.as_deref().unwrap());
+                        let body = this.lower_anon_const_to_const_arg(
+                            body.as_deref().unwrap(),
+                            !this.tcx.features().min_generic_const_args(),
+                        );
                         hir::ImplItemKind::Const(ty, body)
                     },
                 ),
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1084,7 +1084,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             AssocItemConstraintKind::Equality { term } => {
                 let term = match term {
                     Term::Ty(ty) => self.lower_ty(ty, itctx).into(),
-                    Term::Const(c) => self.lower_anon_const_to_const_arg(c).into(),
+                    Term::Const(c) => self.lower_anon_const_to_const_arg(c, false).into(),
                 };
                 hir::AssocItemConstraintKind::Equality { term }
             }
@@ -1210,9 +1210,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 }
                 GenericArg::Type(self.lower_ty(ty, itctx).try_as_ambig_ty().unwrap())
             }
-            ast::GenericArg::Const(ct) => {
-                GenericArg::Const(self.lower_anon_const_to_const_arg(ct).try_as_ambig_ct().unwrap())
-            }
+            ast::GenericArg::Const(ct) => GenericArg::Const(
+                self.lower_anon_const_to_const_arg(ct, false).try_as_ambig_ct().unwrap(),
+            ),
         }
     }
 
@@ -2024,7 +2024,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             false
                         }
                     })
-                    .map(|def| self.lower_anon_const_to_const_arg(def));
+                    .map(|def| self.lower_anon_const_to_const_arg(def, false));
 
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
@@ -2236,7 +2236,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let ct_kind = hir::ConstArgKind::Infer(self.lower_span(c.value.span), ());
                 self.arena.alloc(hir::ConstArg { hir_id: self.lower_node_id(c.id), kind: ct_kind })
             }
-            _ => self.lower_anon_const_to_const_arg(c),
+            _ => self.lower_anon_const_to_const_arg(c, false),
         }
     }
 
@@ -2305,12 +2305,21 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     /// See [`hir::ConstArg`] for when to use this function vs
     /// [`Self::lower_anon_const_to_anon_const`].
-    fn lower_anon_const_to_const_arg(&mut self, anon: &AnonConst) -> &'hir hir::ConstArg<'hir> {
-        self.arena.alloc(self.lower_anon_const_to_const_arg_direct(anon))
+    fn lower_anon_const_to_const_arg(
+        &mut self,
+        anon: &AnonConst,
+        always_lower_to_anon_const: bool,
+    ) -> &'hir hir::ConstArg<'hir> {
+        self.arena
+            .alloc(self.lower_anon_const_to_const_arg_direct(anon, always_lower_to_anon_const))
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
+    fn lower_anon_const_to_const_arg_direct(
+        &mut self,
+        anon: &AnonConst,
+        always_lower_to_anon_const: bool,
+    ) -> hir::ConstArg<'hir> {
         let tcx = self.tcx;
         // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
         // currently have to be wrapped in curly brackets, so it's necessary to special-case.
@@ -2329,6 +2338,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             && path.is_potential_trivial_const_arg(tcx.features().min_generic_const_args())
             && (tcx.features().min_generic_const_args()
                 || matches!(maybe_res, Some(Res::Def(DefKind::ConstParam, _))))
+            && !always_lower_to_anon_const
         {
             let qpath = self.lower_qpath(
                 expr.id,
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
@@ -438,35 +438,36 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_ty_pat_mut(&mut self, pattern: &TyPat, base_type: Span) -> hir::TyPat<'hir> {
         // loop here to avoid recursion
         let pat_hir_id = self.lower_node_id(pattern.id);
-        let node = match &pattern.kind {
-            TyPatKind::Range(e1, e2, Spanned { node: end, span }) => hir::TyPatKind::Range(
-                e1.as_deref().map(|e| self.lower_anon_const_to_const_arg(e)).unwrap_or_else(|| {
-                    self.lower_ty_pat_range_end(
-                        hir::LangItem::RangeMin,
-                        span.shrink_to_lo(),
-                        base_type,
-                    )
-                }),
-                e2.as_deref()
-                    .map(|e| match end {
-                        RangeEnd::Included(..) => self.lower_anon_const_to_const_arg(e),
-                        RangeEnd::Excluded => self.lower_excluded_range_end(e),
-                    })
-                    .unwrap_or_else(|| {
-                        self.lower_ty_pat_range_end(
-                            hir::LangItem::RangeMax,
-                            span.shrink_to_hi(),
-                            base_type,
-                        )
-                    }),
-            ),
-            TyPatKind::Or(variants) => {
-                hir::TyPatKind::Or(self.arena.alloc_from_iter(
+        let node =
+            match &pattern.kind {
+                TyPatKind::Range(e1, e2, Spanned { node: end, span }) => hir::TyPatKind::Range(
+                    e1.as_deref()
+                        .map(|e| self.lower_anon_const_to_const_arg(e, false))
+                        .unwrap_or_else(|| {
+                            self.lower_ty_pat_range_end(
+                                hir::LangItem::RangeMin,
+                                span.shrink_to_lo(),
+                                base_type,
+                            )
+                        }),
+                    e2.as_deref()
+                        .map(|e| match end {
+                            RangeEnd::Included(..) => self.lower_anon_const_to_const_arg(e, false),
+                            RangeEnd::Excluded => self.lower_excluded_range_end(e),
+                        })
+                        .unwrap_or_else(|| {
+                            self.lower_ty_pat_range_end(
+                                hir::LangItem::RangeMax,
+                                span.shrink_to_hi(),
+                                base_type,
+                            )
+                        }),
+                ),
+                TyPatKind::Or(variants) => hir::TyPatKind::Or(self.arena.alloc_from_iter(
                     variants.iter().map(|pat| self.lower_ty_pat_mut(pat, base_type)),
-                ))
-            }
-            TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
-        };
+                )),
+                TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
+            };
 
         hir::TyPat { hir_id: pat_hir_id, kind: node, span: self.lower_span(pattern.span) }
     }
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -352,8 +352,17 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
     {
         let ct = tcx.const_of_item(def_id).instantiate(tcx, key.value.instance.args);
         match ct.kind() {
-            ty::ConstKind::Unevaluated(_) => {
-                return Err(ErrorHandled::TooGeneric(DUMMY_SP));
+            ty::ConstKind::Unevaluated(_) if tcx.features().min_generic_const_args() => {
+                bug!("fully resolving const items under mgca for const eval is not supported yet");
+            }
+            ty::ConstKind::Unevaluated(uv) => {
+                assert_eq!(tcx.def_kind(uv.def), DefKind::AnonConst);
+
+                let id = GlobalId {
+                    instance: ty::Instance { def: ty::InstanceKind::Item(uv.def), args: uv.args },
+                    promoted: None,
+                };
+                return eval_in_interpreter(tcx, id, key.typing_env);
             }
             ty::ConstKind::Value(cv) => return Ok(tcx.valtree_to_const_alloc(cv)),
             ty::ConstKind::Error(guar) => {
@@ -369,7 +378,7 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
             ty::ConstKind::Infer(_) | ty::ConstKind::Bound(..) => {
                 bug!("unexpected constant {ct:?}")
             }
-        }
+        };
     }
 
     eval_in_interpreter(tcx, key.value, key.typing_env)
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -2328,15 +2328,27 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         // generic arguments, just weaker type inference.
         let ty = tcx.type_of(anon.def_id).instantiate_identity();
 
-        match self.try_lower_anon_const_lit(ty, expr) {
-            Some(v) => v,
-            None => ty::Const::new_unevaluated(
+        let mk_uv = || {
+            ty::Const::new_unevaluated(
                 tcx,
                 ty::UnevaluatedConst {
                     def: anon.def_id.to_def_id(),
                     args: ty::GenericArgs::identity_for_item(tcx, anon.def_id.to_def_id()),
                 },
-            ),
+            )
+        };
+
+        // On stable we always lower the anon const on the rhs of const items
+        // to be an anon const.
+        if tcx.anon_const_kind(anon.def_id) == ty::AnonConstKind::ItemBody
+            && !tcx.features().min_generic_const_args()
+        {
+            return mk_uv();
+        }
+
+        match self.try_lower_anon_const_lit(ty, expr) {
+            Some(v) => v,
+            None => mk_uv(),
         }
     }
 
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
@@ -1,6 +1,5 @@
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::LangItem;
-use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::bug;
@@ -98,24 +97,7 @@ fn resolve_instance_raw<'tcx>(
 
         Ok(Some(Instance { def, args }))
     };
-    if let Ok(Some(Instance { def: ty::InstanceKind::Item(def_id), args })) = result
-        && matches!(tcx.def_kind(def_id), DefKind::Const | DefKind::AssocConst)
-    {
-        debug!(" => resolved to const item");
-        let ct = tcx.const_of_item(def_id).instantiate(tcx, args);
-        debug!("ct={ct:?}");
-        if let ty::ConstKind::Unevaluated(uv) = ct.kind() {
-            if tcx.def_kind(uv.def) == DefKind::AnonConst {
-                return Ok(Some(ty::Instance {
-                    def: ty::InstanceKind::Item(uv.def),
-                    args: uv.args,
-                }));
-            } else {
-                let input = PseudoCanonicalInput { typing_env, value: (uv.def, uv.args) };
-                return tcx.resolve_instance_raw(input);
-            }
-        }
-    }
+
     result
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1084,7 +1084,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`1084`	`1084`	`AssocItemConstraintKind::Equality { term } => {`
`1085`	`1085`	`let term = match term {`
`1086`	`1086`	`Term::Ty(ty) => self.lower_ty(ty, itctx).into(),`
`1087`		`- Term::Const(c) => self.lower_anon_const_to_const_arg(c).into(),`
	`1087`	`+ Term::Const(c) => self.lower_anon_const_to_const_arg(c, false).into(),`
`1088`	`1088`	`};`
`1089`	`1089`	`hir::AssocItemConstraintKind::Equality { term }`
`1090`	`1090`	`}`
`@@ -1210,9 +1210,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`1210`	`1210`	`}`
`1211`	`1211`	`GenericArg::Type(self.lower_ty(ty, itctx).try_as_ambig_ty().unwrap())`
`1212`	`1212`	`}`
`1213`		`- ast::GenericArg::Const(ct) => {`
`1214`		`- GenericArg::Const(self.lower_anon_const_to_const_arg(ct).try_as_ambig_ct().unwrap())`
`1215`		`- }`
	`1213`	`+ ast::GenericArg::Const(ct) => GenericArg::Const(`
	`1214`	`+ self.lower_anon_const_to_const_arg(ct, false).try_as_ambig_ct().unwrap(),`
	`1215`	`+ ),`
`1216`	`1216`	`}`
`1217`	`1217`	`}`
`1218`	`1218`
`@@ -2024,7 +2024,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`2024`	`2024`	`false`
`2025`	`2025`	`}`
`2026`	`2026`	`})`
`2027`		`- .map(\|def\| self.lower_anon_const_to_const_arg(def));`
	`2027`	`+ .map(\|def\| self.lower_anon_const_to_const_arg(def, false));`
`2028`	`2028`
`2029`	`2029`	`(`
`2030`	`2030`	`hir::ParamName::Plain(self.lower_ident(param.ident)),`
`@@ -2236,7 +2236,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`2236`	`2236`	`let ct_kind = hir::ConstArgKind::Infer(self.lower_span(c.value.span), ());`
`2237`	`2237`	`self.arena.alloc(hir::ConstArg { hir_id: self.lower_node_id(c.id), kind: ct_kind })`
`2238`	`2238`	`}`
`2239`		`- _ => self.lower_anon_const_to_const_arg(c),`
	`2239`	`+ _ => self.lower_anon_const_to_const_arg(c, false),`
`2240`	`2240`	`}`
`2241`	`2241`	`}`
`2242`	`2242`
`@@ -2305,12 +2305,21 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`2305`	`2305`
`2306`	`2306`	/// See [`hir::ConstArg`] for when to use this function vs
`2307`	`2307`	/// [`Self::lower_anon_const_to_anon_const`].
`2308`		`- fn lower_anon_const_to_const_arg(&mut self, anon: &AnonConst) -> &'hir hir::ConstArg<'hir> {`
`2309`		`- self.arena.alloc(self.lower_anon_const_to_const_arg_direct(anon))`
	`2308`	`+ fn lower_anon_const_to_const_arg(`
	`2309`	`+ &mut self,`
	`2310`	`+ anon: &AnonConst,`
	`2311`	`+ always_lower_to_anon_const: bool,`
	`2312`	`+ ) -> &'hir hir::ConstArg<'hir> {`
	`2313`	`+ self.arena`
	`2314`	`+ .alloc(self.lower_anon_const_to_const_arg_direct(anon, always_lower_to_anon_const))`
`2310`	`2315`	`}`
`2311`	`2316`
`2312`	`2317`	`#[instrument(level = "debug", skip(self))]`
`2313`		`- fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {`
	`2318`	`+ fn lower_anon_const_to_const_arg_direct(`
	`2319`	`+ &mut self,`
	`2320`	`+ anon: &AnonConst,`
	`2321`	`+ always_lower_to_anon_const: bool,`
	`2322`	`+ ) -> hir::ConstArg<'hir> {`
`2314`	`2323`	`let tcx = self.tcx;`
`2315`	`2324`	// Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
`2316`	`2325`	`// currently have to be wrapped in curly brackets, so it's necessary to special-case.`
`@@ -2329,6 +2338,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {`
`2329`	`2338`	`&& path.is_potential_trivial_const_arg(tcx.features().min_generic_const_args())`
`2330`	`2339`	`&& (tcx.features().min_generic_const_args()`
`2331`	`2340`	`\|\| matches!(maybe_res, Some(Res::Def(DefKind::ConstParam, _))))`
	`2341`	`+ && !always_lower_to_anon_const`
`2332`	`2342`	`{`
`2333`	`2343`	`let qpath = self.lower_qpath(`
`2334`	`2344`	`expr.id,`