const_block_items: do not create an AnonConst

Author: GrigorenkoPV

compiler/rustc_ast/src/ast.rs

@@ -3808,8 +3808,9 @@ impl ConstItemRhs {
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct ConstBlockItem {
-    // FIXME(const_block_items): current invariant is body.kind == InlineConst
-    pub body: Box<Expr>,
+    pub id: NodeId,
+    pub span: Span,
+    pub block: Box<Block>,
 }
 
 impl ConstBlockItem {

compiler/rustc_ast_lowering/src/item.rs

@@ -206,12 +206,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 self.lower_define_opaque(hir_id, &define_opaque);
                 hir::ItemKind::Const(ident, generics, ty, rhs)
             }
-            ItemKind::ConstBlock(ConstBlockItem { body }) => hir::ItemKind::Const(
+            ItemKind::ConstBlock(ConstBlockItem { span, id, block }) => hir::ItemKind::Const(
                 self.lower_ident(ConstBlockItem::IDENT),
                 hir::Generics::empty(),
                 self.arena.alloc(self.ty_tup(DUMMY_SP, &[])),
                 hir::ConstItemRhs::Body({
-                    let body = self.lower_expr_mut(body);
+                    let body = hir::Expr {
+                        hir_id: self.lower_node_id(*id),
+                        kind: hir::ExprKind::Block(self.lower_block(block, false), None),
+                        span: self.lower_span(*span),
+                    };
                     self.record_body(&[], body)
                 }),
             ),

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -205,8 +205,16 @@ impl<'a> State<'a> {
                     define_opaque.as_deref(),
                 );
             }
-            ast::ItemKind::ConstBlock(ast::ConstBlockItem { body }) => {
-                self.print_expr(body, FixupContext::default())
+            ast::ItemKind::ConstBlock(ast::ConstBlockItem { id: _, span: _, block }) => {
+                let ib = self.ibox(INDENT_UNIT);
+                self.word("const");
+                self.nbsp();
+                {
+                    let cb = self.cbox(0);
+                    let ib = self.ibox(0);
+                    self.print_block_with_attrs(block, &[], cb, ib);
+                }
+                self.end(ib);
             }
             ast::ItemKind::Const(box ast::ConstItem {
                 defaultness,

compiler/rustc_parse/src/parser/item.rs

@@ -269,15 +269,13 @@ impl<'a> Parser<'a> {
             self.parse_item_impl(attrs, def_())?
         } else if let AllowConstBlockItems::Yes | AllowConstBlockItems::DoesNotMatter =
             allow_const_block_items
-            && self.token.is_keyword(kw::Const)
-            && self.look_ahead(1, |t| *t == token::OpenBrace || t.is_metavar_block())
+            && self.check_inline_const(0)
         {
             // CONST BLOCK ITEM
-            self.psess.gated_spans.gate(sym::const_block_items, self.token.span);
             if let AllowConstBlockItems::DoesNotMatter = allow_const_block_items {
                 debug!("Parsing a const block item that does not matter: {:?}", self.token.span);
             };
-            ItemKind::ConstBlock(ConstBlockItem { body: self.parse_expr()? })
+            ItemKind::ConstBlock(self.parse_const_block_item()?)
         } else if let Const::Yes(const_span) = self.parse_constness(case) {
             // CONST ITEM
             self.recover_const_mut(const_span);
@@ -1395,6 +1393,14 @@ impl<'a> Parser<'a> {
         }
     }
 
+    fn parse_const_block_item(&mut self) -> PResult<'a, ConstBlockItem> {
+        self.expect_keyword(exp!(Const))?;
+        let const_span = self.prev_token.span;
+        self.psess.gated_spans.gate(sym::const_block_items, const_span);
+        let block = self.parse_block()?;
+        Ok(ConstBlockItem { id: DUMMY_NODE_ID, span: const_span.to(block.span), block })
+    }
+
     /// Parse a static item with the prefix `"static" "mut"?` already parsed and stored in
     /// `mutability`.
     ///

compiler/rustc_resolve/src/late.rs

@@ -2857,23 +2857,27 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 );
                 self.resolve_define_opaques(define_opaque);
             }
-            ItemKind::ConstBlock(ConstBlockItem { body }) => self.with_generic_param_rib(
-                &[],
-                RibKind::Item(HasGenericParams::No, def_kind),
-                item.id,
-                LifetimeBinderKind::ConstItem,
-                DUMMY_SP,
-                |this| {
-                    this.with_lifetime_rib(LifetimeRibKind::Elided(LifetimeRes::Infer), |this| {
-                        this.with_constant_rib(
-                            IsRepeatExpr::No,
-                            ConstantHasGenerics::Yes,
-                            Some((ConstBlockItem::IDENT, ConstantItemKind::Const)),
-                            |this| this.visit_expr(body),
+            ItemKind::ConstBlock(ConstBlockItem { id: _, span: _, block }) => self
+                .with_generic_param_rib(
+                    &[],
+                    RibKind::Item(HasGenericParams::No, def_kind),
+                    item.id,
+                    LifetimeBinderKind::ConstItem,
+                    DUMMY_SP,
+                    |this| {
+                        this.with_lifetime_rib(
+                            LifetimeRibKind::Elided(LifetimeRes::Infer),
+                            |this| {
+                                this.with_constant_rib(
+                                    IsRepeatExpr::No,
+                                    ConstantHasGenerics::Yes,
+                                    Some((ConstBlockItem::IDENT, ConstantItemKind::Const)),
+                                    |this| this.resolve_labeled_block(None, block.id, block),
+                                )
+                            },
                         );
-                    })
-                },
-            ),
+                    },
+                ),
 
             ItemKind::Use(use_tree) => {
                 let maybe_exported = match use_tree.kind {