Use AnonConst as RHS of const items instead of side channel hack

camelid · camelid · commit 123f00eb9d08 · 2025-05-22T15:26:34.000+01:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -3617,12 +3617,7 @@ pub struct ConstItem {
     pub ident: Ident,
     pub generics: Generics,
     pub ty: P<Ty>,
-    /// A [`NodeId`] that can be used for the body of the const, independently of the ID
-    /// of the body's root expression.
-    // HACK(mgca): this is potentially temporary, tbd, in order to create defs for const bodies.
-    // FIXME(mgca): maybe merge this with expr since their Options should be in sync
-    pub body_id: Option<NodeId>,
-    pub expr: Option<P<Expr>>,
+    pub body: Option<P<AnonConst>>,
     pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
 }
 
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -1331,13 +1331,12 @@ impl WalkItemKind for AssocItemKind {
 }
 
 fn walk_const_item<T: MutVisitor>(vis: &mut T, item: &mut ConstItem) {
-    let ConstItem { defaultness, ident, generics, ty, body_id, expr, define_opaque } = item;
+    let ConstItem { defaultness, ident, generics, ty, body, define_opaque } = item;
     visit_defaultness(vis, defaultness);
     vis.visit_ident(ident);
     vis.visit_generics(generics);
     vis.visit_ty(ty);
-    visit_opt(body_id, |body_id| vis.visit_id(body_id));
-    visit_opt(expr, |expr| vis.visit_expr(expr));
+    visit_opt(body, |body| vis.visit_anon_const(body));
     walk_define_opaques(vis, define_opaque);
 }
 
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -388,14 +388,13 @@ impl WalkItemKind for ItemKind {
                 ident,
                 generics,
                 ty,
-                body_id: _,
-                expr,
+                body,
                 define_opaque,
             }) => {
                 try_visit!(visitor.visit_ident(ident));
                 try_visit!(visitor.visit_generics(generics));
                 try_visit!(visitor.visit_ty(ty));
-                visit_opt!(visitor, visit_expr, expr);
+                visit_opt!(visitor, visit_anon_const, body);
                 try_visit!(walk_define_opaques(visitor, define_opaque));
             }
             ItemKind::Fn(func) => {
@@ -991,14 +990,13 @@ impl WalkItemKind for AssocItemKind {
                 ident,
                 generics,
                 ty,
-                body_id: _,
-                expr,
+                body,
                 define_opaque,
             }) => {
                 try_visit!(visitor.visit_ident(ident));
                 try_visit!(visitor.visit_generics(generics));
                 try_visit!(visitor.visit_ty(ty));
-                visit_opt!(visitor, visit_expr, expr);
+                visit_opt!(visitor, visit_anon_const, body);
                 try_visit!(walk_define_opaques(visitor, define_opaque));
             }
             AssocItemKind::Fn(func) => {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -199,8 +199,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ident,
                 generics,
                 ty,
-                body_id,
-                expr,
+                body,
                 define_opaque,
                 ..
             }) => {
@@ -212,8 +211,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     |this| {
                         let ty = this
                             .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
-                        let body =
-                            this.lower_const_item(span, body_id.unwrap(), expr.as_deref().unwrap());
+                        let body = this.lower_const_item(body.as_deref().unwrap());
                         (ty, body)
                     },
                 );
@@ -498,25 +496,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn lower_const_item(
-        &mut self,
-        span: Span,
-        body_id: NodeId,
-        body_expr: &Expr,
-    ) -> &'hir hir::ConstArg<'hir> {
+    fn lower_const_item(&mut self, body: &AnonConst) -> &'hir hir::ConstArg<'hir> {
         let mgca = self.tcx.features().min_generic_const_args();
-        if mgca && let Some(ct_arg) = self.try_lower_as_const_path(body_expr) {
+        if mgca && let Some(ct_arg) = self.try_lower_as_const_path(body) {
             return ct_arg;
         }
-        let anon = self.arena.alloc(self.with_new_scopes(span, |this| {
-            let body = this.lower_const_body(span, Some(body_expr));
-            hir::AnonConst {
-                hir_id: this.lower_node_id(body_id),
-                def_id: this.local_def_id(body_id),
-                body,
-                span,
-            }
-        }));
+        let anon = self.lower_anon_const_to_anon_const(body);
         self.arena
             .alloc(hir::ConstArg { hir_id: self.next_id(), kind: hir::ConstArgKind::Anon(anon) })
     }
@@ -816,8 +801,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ident,
                 generics,
                 ty,
-                body_id,
-                expr,
+                body,
                 define_opaque,
                 ..
             }) => {
@@ -828,15 +812,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     |this| {
                         let ty = this
                             .lower_ty(ty, ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy));
-                        let body = body_id
-                            .zip(expr.as_deref())
-                            .map(|(b_id, b_ex)| this.lower_const_item(i.span, b_id, b_ex));
+                        let body = body.as_deref().map(|body| this.lower_const_item(body));
                         hir::TraitItemKind::Const(ty, body)
                     },
                 );
 
                 if define_opaque.is_some() {
-                    if expr.is_some() {
+                    if body.is_some() {
                         self.lower_define_opaque(hir_id, &define_opaque);
                     } else {
                         self.dcx().span_err(
@@ -846,7 +828,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     }
                 }
 
-                (*ident, generics, kind, expr.is_some())
+                (*ident, generics, kind, body.is_some())
             }
             AssocItemKind::Fn(box Fn {
                 sig, ident, generics, body: None, define_opaque, ..
@@ -1010,8 +992,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ident,
                 generics,
                 ty,
-                body_id,
-                expr,
+                body,
                 define_opaque,
                 ..
             }) => (
@@ -1024,11 +1005,7 @@ 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_const_item(
-                            i.span,
-                            body_id.unwrap(),
-                            expr.as_deref().unwrap(),
-                        );
+                        let body = this.lower_const_item(body.as_deref().unwrap());
                         hir::ImplItemKind::Const(ty, body)
                     },
                 ),
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2085,10 +2085,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     }
 
     /// Assumes mgca feature is enabled.
-    fn try_lower_as_const_path(&mut self, expr: &Expr) -> Option<&'hir hir::ConstArg<'hir>> {
-        let ExprKind::Path(qself, path) = &expr.kind else { return None };
+    fn try_lower_as_const_path(&mut self, body: &AnonConst) -> Option<&'hir hir::ConstArg<'hir>> {
+        let ExprKind::Path(qself, path) = &body.value.kind else { return None };
         let qpath = self.lower_qpath(
-            expr.id,
+            body.value.id,
             qself,
             path,
             ParamMode::Optional,
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1084,9 +1084,9 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     _ => visit::walk_item(self, item),
                 }
             }
-            ItemKind::Const(box ConstItem { defaultness, expr, .. }) => {
+            ItemKind::Const(box ConstItem { defaultness, body, .. }) => {
                 self.check_defaultness(item.span, *defaultness);
-                if expr.is_none() {
+                if body.is_none() {
                     self.dcx().emit_err(errors::ConstWithoutBody {
                         span: item.span,
                         replace_span: self.ending_semi_or_hi(item.span),
@@ -1436,7 +1436,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 
         if let AssocCtxt::Impl { .. } = ctxt {
             match &item.kind {
-                AssocItemKind::Const(box ConstItem { expr: None, .. }) => {
+                AssocItemKind::Const(box ConstItem { body: None, .. }) => {
                     self.dcx().emit_err(errors::AssocConstWithoutBody {
                         span: item.span,
                         replace_span: self.ending_semi_or_hi(item.span),
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -214,16 +214,15 @@ impl<'a> State<'a> {
                 ident,
                 generics,
                 ty,
-                body_id: _,
-                expr,
+                body,
                 define_opaque,
             }) => {
                 self.print_item_const(
                     *ident,
                     None,
                     generics,
                     ty,
-                    expr.as_deref(),
+                    body.as_deref().map(|ct| &*ct.value),
                     &item.vis,
                     ast::Safety::Default,
                     *defaultness,
@@ -564,16 +563,15 @@ impl<'a> State<'a> {
                 ident,
                 generics,
                 ty,
-                body_id: _,
-                expr,
+                body,
                 define_opaque,
             }) => {
                 self.print_item_const(
                     *ident,
                     None,
                     generics,
                     ty,
-                    expr.as_deref(),
+                    body.as_deref().map(|ct| &*ct.value),
                     vis,
                     ast::Safety::Default,
                     *defaultness,
diff --git a/compiler/rustc_builtin_macros/src/alloc_error_handler.rs b/compiler/rustc_builtin_macros/src/alloc_error_handler.rs
@@ -43,7 +43,7 @@ pub(crate) fn expand(
 
     // Generate anonymous constant serving as container for the allocator methods.
     let const_ty = ecx.ty(sig_span, TyKind::Tup(ThinVec::new()));
-    let const_body = ecx.expr_block(ecx.block(span, stmts));
+    let const_body = ecx.anon_const_block(ecx.block(span, stmts));
     let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
     let const_item = if is_stmt {
         Annotatable::Stmt(P(ecx.stmt_item(span, const_item)))
diff --git a/compiler/rustc_builtin_macros/src/global_allocator.rs b/compiler/rustc_builtin_macros/src/global_allocator.rs
@@ -48,7 +48,7 @@ pub(crate) fn expand(
 
     // Generate anonymous constant serving as container for the allocator methods.
     let const_ty = ecx.ty(ty_span, TyKind::Tup(ThinVec::new()));
-    let const_body = ecx.expr_block(ecx.block(span, stmts));
+    let const_body = ecx.anon_const_block(ecx.block(span, stmts));
     let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
     let const_item = if is_stmt {
         Annotatable::Stmt(P(ecx.stmt_item(span, const_item)))
diff --git a/compiler/rustc_builtin_macros/src/proc_macro_harness.rs b/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
@@ -379,7 +379,7 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> P<ast::Item> {
             i
         });
 
-    let block = cx.expr_block(
+    let block = cx.anon_const_block(
         cx.block(span, thin_vec![cx.stmt_item(span, krate), cx.stmt_item(span, decls_static)]),
     );
 
diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
@@ -293,10 +293,10 @@ pub(crate) fn expand_test_or_bench(
                     generics: ast::Generics::default(),
                     ty: cx.ty(sp, ast::TyKind::Path(None, test_path("TestDescAndFn"))),
                     define_opaque: None,
-                    body_id: Some(ast::DUMMY_NODE_ID),
                     // test::TestDescAndFn {
-                    expr: Some(
-                        cx.expr_struct(
+                    body: Some(P(ast::AnonConst {
+                        id: ast::DUMMY_NODE_ID,
+                        value: cx.expr_struct(
                             sp,
                             test_path("TestDescAndFn"),
                             thin_vec![
@@ -377,7 +377,7 @@ pub(crate) fn expand_test_or_bench(
                         field("testfn", test_fn), // }
                     ],
                         ), // }
-                    ),
+                    })),
                 }
                 .into(),
             ),
diff --git a/compiler/rustc_expand/src/build.rs b/compiler/rustc_expand/src/build.rs
@@ -105,6 +105,10 @@ impl<'a> ExtCtxt<'a> {
         }
     }
 
+    pub fn anon_const_block(&self, b: P<ast::Block>) -> P<ast::AnonConst> {
+        P(self.anon_const(b.span, ast::ExprKind::Block(b, None)))
+    }
+
     pub fn const_ident(&self, span: Span, ident: Ident) -> ast::AnonConst {
         self.anon_const(span, ast::ExprKind::Path(None, self.path_ident(span, ident)))
     }
@@ -711,7 +715,7 @@ impl<'a> ExtCtxt<'a> {
         span: Span,
         ident: Ident,
         ty: P<ast::Ty>,
-        expr: P<ast::Expr>,
+        body: P<ast::AnonConst>,
     ) -> P<ast::Item> {
         let defaultness = ast::Defaultness::Final;
         self.item(
@@ -724,8 +728,7 @@ impl<'a> ExtCtxt<'a> {
                     // FIXME(generic_const_items): Pass the generics as a parameter.
                     generics: ast::Generics::default(),
                     ty,
-                    body_id: Some(ast::DUMMY_NODE_ID),
-                    expr: Some(expr),
+                    body: Some(body),
                     define_opaque: None,
                 }
                 .into(),
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
@@ -95,9 +95,8 @@ use rustc_abi::ExternAbi;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_middle::middle;
-use rustc_middle::mir::interpret::GlobalId;
 use rustc_middle::query::Providers;
-use rustc_middle::ty::{self, Const, Ty, TyCtxt};
+use rustc_middle::ty::{Const, Ty, TyCtxt};
 use rustc_session::parse::feature_err;
 use rustc_span::symbol::sym;
 use rustc_span::{ErrorGuaranteed, Span};
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
@@ -983,19 +983,22 @@ trait UnusedDelimLint {
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) {
         use ast::ItemKind::*;
 
-        if let Const(box ast::ConstItem { expr: Some(expr), .. })
-        | Static(box ast::StaticItem { expr: Some(expr), .. }) = &item.kind
-        {
-            self.check_unused_delims_expr(
-                cx,
-                expr,
-                UnusedDelimsCtx::AssignedValue,
-                false,
-                None,
-                None,
-                false,
-            );
-        }
+        let expr = if let Const(box ast::ConstItem { body: Some(body), .. }) = &item.kind {
+            &body.value
+        } else if let Static(box ast::StaticItem { expr: Some(expr), .. }) = &item.kind {
+            expr
+        } else {
+            return;
+        };
+        self.check_unused_delims_expr(
+            cx,
+            expr,
+            UnusedDelimsCtx::AssignedValue,
+            false,
+            None,
+            None,
+            false,
+        );
     }
 }
 
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs

Original file line number	Diff line number	Diff line change
`@@ -1331,13 +1331,12 @@ impl WalkItemKind for AssocItemKind {`
`1331`	`1331`	`}`
`1332`	`1332`
`1333`	`1333`	`fn walk_const_item<T: MutVisitor>(vis: &mut T, item: &mut ConstItem) {`
`1334`		`- let ConstItem { defaultness, ident, generics, ty, body_id, expr, define_opaque } = item;`
	`1334`	`+ let ConstItem { defaultness, ident, generics, ty, body, define_opaque } = item;`
`1335`	`1335`	`visit_defaultness(vis, defaultness);`
`1336`	`1336`	`vis.visit_ident(ident);`
`1337`	`1337`	`vis.visit_generics(generics);`
`1338`	`1338`	`vis.visit_ty(ty);`
`1339`		`- visit_opt(body_id, \|body_id\| vis.visit_id(body_id));`
`1340`		`- visit_opt(expr, \|expr\| vis.visit_expr(expr));`
	`1339`	`+ visit_opt(body, \|body\| vis.visit_anon_const(body));`
`1341`	`1340`	`walk_define_opaques(vis, define_opaque);`
`1342`	`1341`	`}`
`1343`	`1342`
Original file line number	Diff line number	Diff line change
`@@ -379,7 +379,7 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> P<ast::Item> {`
`379`	`379`	`i`
`380`	`380`	`});`
`381`	`381`
`382`		`- let block = cx.expr_block(`
	`382`	`+ let block = cx.anon_const_block(`
`383`	`383`	`cx.block(span, thin_vec![cx.stmt_item(span, krate), cx.stmt_item(span, decls_static)]),`
`384`	`384`	`);`
`385`	`385`