Rollup of 12 pull requests

compiler/rustc_ast/src/ast.rs

@@ -4010,44 +4010,16 @@ pub struct ConstItem {
     pub ident: Ident,
     pub generics: Generics,
     pub ty: Box<Ty>,
-    pub rhs_kind: ConstItemRhsKind,
+    pub body: Option<Box<Expr>>,
+    #[visitable(ignore)]
+    pub kind: ConstItemKind,
     pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
 }
 
-#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
-pub enum ConstItemRhsKind {
-    Body { rhs: Option<Box<Expr>> },
-    TypeConst { rhs: Option<AnonConst> },
-}
-
-impl ConstItemRhsKind {
-    pub fn new_body(rhs: Box<Expr>) -> Self {
-        Self::Body { rhs: Some(rhs) }
-    }
-
-    pub fn span(&self) -> Option<Span> {
-        Some(self.expr()?.span)
-    }
-
-    pub fn expr(&self) -> Option<&Expr> {
-        match self {
-            Self::Body { rhs: Some(body) } => Some(&body),
-            Self::TypeConst { rhs: Some(anon) } => Some(&anon.value),
-            _ => None,
-        }
-    }
-
-    pub fn has_expr(&self) -> bool {
-        match self {
-            Self::Body { rhs: Some(_) } => true,
-            Self::TypeConst { rhs: Some(_) } => true,
-            _ => false,
-        }
-    }
-
-    pub fn is_type_const(&self) -> bool {
-        matches!(self, &Self::TypeConst { .. })
-    }
+#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Eq)]
+pub enum ConstItemKind {
+    Body,
+    TypeConst,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]

compiler/rustc_ast/src/visit.rs

@@ -427,7 +427,6 @@ macro_rules! common_visitor_and_walkers {
             Const,
             ConstBlockItem,
             ConstItem,
-            ConstItemRhsKind,
             Defaultness,
             Delegation,
             DelegationMac,

compiler/rustc_ast_lowering/src/item.rs

@@ -270,7 +270,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ident,
                 generics,
                 ty,
-                rhs_kind,
+                body,
+                kind,
                 define_opaque,
             }) => {
                 let ident = self.lower_ident(*ident);
@@ -282,7 +283,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ty,
                             ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
                         );
-                        let rhs = this.lower_const_item_rhs(rhs_kind, span);
+                        let rhs = this.lower_const_item_rhs(body, *kind, span);
                         (ty, rhs)
                     },
                 );
@@ -918,7 +919,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ident,
                 generics,
                 ty,
-                rhs_kind,
+                body,
+                kind,
                 define_opaque,
                 ..
             }) => {
@@ -931,8 +933,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
                         );
                         // Trait associated consts don't need an expression/body.
-                        let rhs = if rhs_kind.has_expr() {
-                            Some(this.lower_const_item_rhs(rhs_kind, i.span))
+                        let rhs = if body.is_some() {
+                            Some(this.lower_const_item_rhs(body, *kind, i.span))
                         } else {
                             None
                         };
@@ -941,7 +943,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 );
 
                 if define_opaque.is_some() {
-                    if rhs_kind.has_expr() {
+                    if body.is_some() {
                         self.lower_define_opaque(hir_id, &define_opaque);
                     } else {
                         self.dcx().span_err(
@@ -951,7 +953,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     }
                 }
 
-                (*ident, generics, kind, rhs_kind.has_expr())
+                (*ident, generics, kind, body.is_some())
             }
             AssocItemKind::Fn(Fn { sig, ident, generics, body: None, define_opaque, .. }) => {
                 // FIXME(contracts): Deny contract here since it won't apply to
@@ -1180,7 +1182,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ident,
                 generics,
                 ty,
-                rhs_kind,
+                body,
+                kind,
                 define_opaque,
                 ..
             }) => (
@@ -1194,7 +1197,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
                         );
                         this.lower_define_opaque(hir_id, &define_opaque);
-                        let rhs = this.lower_const_item_rhs(rhs_kind, i.span);
+                        let rhs = this.lower_const_item_rhs(body, *kind, i.span);
                         hir::ImplItemKind::Const(ty, rhs)
                     },
                 ),

compiler/rustc_ast_lowering/src/lib.rs

@@ -2671,28 +2671,26 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_const_item_rhs(
         &mut self,
-        rhs_kind: &ConstItemRhsKind,
+        body: &Option<Box<Expr>>,
+        kind: ConstItemKind,
         span: Span,
     ) -> hir::ConstItemRhs<'hir> {
-        match rhs_kind {
-            ConstItemRhsKind::Body { rhs: Some(body) } => {
-                hir::ConstItemRhs::Body(self.lower_const_body(span, Some(body)))
+        match (body, kind) {
+            (body, ConstItemKind::Body) => {
+                hir::ConstItemRhs::Body(self.lower_const_body(span, body.as_deref()))
             }
-            ConstItemRhsKind::Body { rhs: None } => {
-                hir::ConstItemRhs::Body(self.lower_const_body(span, None))
-            }
-            ConstItemRhsKind::TypeConst { rhs: Some(anon) } => {
+            (Some(body), ConstItemKind::TypeConst) => {
                 hir::ConstItemRhs::TypeConst(self.arena.alloc(
                     match self.can_lower_expr_to_const_arg_direct(
-                        &anon.value,
+                        &body,
                         DirectConstArgContext::MacrolessMinGenericConstArgs,
                     ) {
-                        Ok(()) => self.lower_expr_to_const_arg_direct(&anon.value, Some(anon.id)),
+                        Ok(()) => self.lower_expr_to_const_arg_direct(&body, None),
                         Err(err) => err.emit(self),
                     },
                 ))
             }
-            ConstItemRhsKind::TypeConst { rhs: None } => {
+            (None, ConstItemKind::TypeConst) => {
                 let const_arg = ConstArg {
                     hir_id: self.next_id(),
                     kind: hir::ConstArgKind::Error(

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1544,9 +1544,9 @@ impl Visitor<'_> for AstValidator<'_> {
                     visit::walk_item(this, item)
                 });
             }
-            ItemKind::Const(ConstItem { defaultness, ident, rhs_kind, .. }) => {
+            ItemKind::Const(ConstItem { defaultness, ident, body, .. }) => {
                 self.check_defaultness(item.span, *defaultness, AllowDefault::No, AllowFinal::No);
-                if !rhs_kind.has_expr() {
+                if body.is_none() {
                     self.dcx().emit_err(diagnostics::ConstWithoutBody {
                         span: item.span,
                         replace_span: self.ending_semi_or_hi(item.span),
@@ -1941,8 +1941,8 @@ impl Visitor<'_> for AstValidator<'_> {
 
         if let AssocCtxt::Impl { .. } = ctxt {
             match &item.kind {
-                AssocItemKind::Const(ConstItem { rhs_kind, .. }) => {
-                    if !rhs_kind.has_expr() {
+                AssocItemKind::Const(ConstItem { body, .. }) => {
+                    if body.is_none() {
                         self.dcx().emit_err(diagnostics::AssocConstWithoutBody {
                             span: item.span,
                             replace_span: self.ending_semi_or_hi(item.span),

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,4 +1,4 @@
-use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
+use rustc_ast::visit::{self, AssocCtxt, FnKind, Visitor};
 use rustc_ast::{self as ast, AttrVec, GenericBound, NodeId, PatKind, attr, token};
 use rustc_attr_parsing::AttributeParser;
 use rustc_errors::msg;
@@ -220,8 +220,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 self.check_impl_trait(ty, false)
             }
             ast::ItemKind::Const(ast::ConstItem {
-                rhs_kind: ast::ConstItemRhsKind::TypeConst { .. },
-                ..
+                kind: ast::ConstItemKind::TypeConst, ..
             }) => {
                 // Make sure this is only allowed if the feature gate is enabled.
                 // #![feature(min_generic_const_args)]
@@ -366,7 +365,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
         visit::walk_poly_trait_ref(self, t);
     }
 
-    fn visit_fn(&mut self, fn_kind: FnKind<'a>, _: &AttrVec, span: Span, _: NodeId) {
+    fn visit_fn(&mut self, fn_kind: FnKind<'a>, _: &AttrVec, _: Span, _: NodeId) {
         if let Some(_header) = fn_kind.header() {
             // Stability of const fn methods are covered in `visit_assoc_item` below.
         }
@@ -375,10 +374,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             self.check_late_bound_lifetime_defs(generic_params);
         }
 
-        if fn_kind.ctxt() != Some(FnCtxt::Foreign) && fn_kind.decl().c_variadic() {
-            gate!(self, c_variadic, span, "C-variadic functions are unstable");
-        }
-
         visit::walk_fn(self, fn_kind)
     }
 
@@ -400,7 +395,8 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 false
             }
             ast::AssocItemKind::Const(ast::ConstItem {
-                rhs_kind: ast::ConstItemRhsKind::TypeConst { rhs },
+                body,
+                kind: ast::ConstItemKind::TypeConst,
                 ..
             }) => {
                 // Make sure this is only allowed if the feature gate is enabled.
@@ -409,7 +405,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 // Make sure associated `type const` defaults in traits are only allowed
                 // if the feature gate is enabled.
                 // #![feature(associated_type_defaults)]
-                if ctxt == AssocCtxt::Trait && rhs.is_some() {
+                if ctxt == AssocCtxt::Trait && body.is_some() {
                     gate!(
                         self,
                         associated_type_defaults,
@@ -730,8 +726,10 @@ fn check_new_solver_banned_features(sess: &Session, features: &Features) {
         .find(|feat| feat.gate_name == sym::generic_const_exprs)
         .map(|feat| feat.attr_sp)
     {
+        // Abort immediately, otherwise GCE can lower to `ConstKind::Expr`,
+        // which the new solver intentionally does not support.
         #[allow(rustc::symbol_intern_string_literal)]
-        sess.dcx().emit_err(diagnostics::IncompatibleFeatures {
+        sess.dcx().emit_fatal(diagnostics::IncompatibleFeatures {
             spans: vec![gce_span],
             f1: Symbol::intern("-Znext-solver=globally"),
             f2: sym::generic_const_exprs,

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

@@ -229,15 +229,16 @@ impl<'a> State<'a> {
                 ident,
                 generics,
                 ty,
-                rhs_kind,
+                body,
+                kind: _,
                 define_opaque,
             }) => {
                 self.print_item_const(
                     *ident,
                     None,
                     generics,
                     ty,
-                    rhs_kind.expr(),
+                    body.as_deref(),
                     &item.vis,
                     ast::Safety::Default,
                     *defaultness,
@@ -617,15 +618,16 @@ impl<'a> State<'a> {
                 ident,
                 generics,
                 ty,
-                rhs_kind,
+                body,
+                kind: _,
                 define_opaque,
             }) => {
                 self.print_item_const(
                     *ident,
                     None,
                     generics,
                     ty,
-                    rhs_kind.expr(),
+                    body.as_deref(),
                     vis,
                     ast::Safety::Default,
                     *defaultness,

compiler/rustc_attr_parsing/src/attributes/util.rs

@@ -1,9 +1,9 @@
 use std::num::IntErrorKind;
 
 use rustc_ast::{LitKind, ast};
+use rustc_data_structures::Limit;
 use rustc_feature::is_builtin_attr_name;
 use rustc_hir::RustcVersion;
-use rustc_hir::limit::Limit;
 use rustc_span::Symbol;
 
 use crate::context::AcceptContext;

compiler/rustc_builtin_macros/src/alloc_error_handler.rs

@@ -43,8 +43,14 @@ 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 = ast::ConstItemRhsKind::new_body(ecx.expr_block(ecx.block(span, stmts)));
-    let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
+    let const_body = ecx.expr_block(ecx.block(span, stmts));
+    let const_item = ecx.item_const(
+        span,
+        Ident::new(kw::Underscore, span),
+        const_ty,
+        Some(const_body),
+        ast::ConstItemKind::Body,
+    );
     let const_item = if is_stmt {
         Annotatable::Stmt(Box::new(ecx.stmt_item(span, const_item)))
     } else {

compiler/rustc_builtin_macros/src/eii.rs

@@ -335,7 +335,8 @@ fn generate_default_impl(
             span,
             underscore,
             unit,
-            ast::ConstItemRhsKind::new_body(ecx.expr_block(ecx.block(span, stmts))),
+            Some(ecx.expr_block(ecx.block(span, stmts))),
+            ast::ConstItemKind::Body,
         )
     };
 

compiler/rustc_builtin_macros/src/global_allocator.rs

@@ -54,8 +54,14 @@ 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 = ast::ConstItemRhsKind::new_body(ecx.expr_block(ecx.block(span, stmts)));
-    let const_item = ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, const_body);
+    let const_body = ecx.expr_block(ecx.block(span, stmts));
+    let const_item = ecx.item_const(
+        span,
+        Ident::new(kw::Underscore, span),
+        const_ty,
+        Some(const_body),
+        ast::ConstItemKind::Body,
+    );
     let const_item = if is_stmt {
         Annotatable::Stmt(Box::new(ecx.stmt_item(span, const_item)))
     } else {

compiler/rustc_builtin_macros/src/proc_macro_harness.rs

@@ -361,15 +361,16 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> Box<ast::Item> {
         cx.attr_nested_word(sym::allow, sym::deprecated, span),
     ]);
 
-    let block = ast::ConstItemRhsKind::new_body(cx.expr_block(
+    let block = cx.expr_block(
         cx.block(span, thin_vec![cx.stmt_item(span, krate), cx.stmt_item(span, decls_static)]),
-    ));
+    );
 
     let anon_constant = cx.item_const(
         span,
         Ident::new(kw::Underscore, span),
         cx.ty(span, ast::TyKind::Tup(ThinVec::new())),
-        block,
+        Some(block),
+        ast::ConstItemKind::Body,
     );
 
     // Integrate the new item into existing module structures.

compiler/rustc_builtin_macros/src/test.rs

@@ -286,8 +286,9 @@ 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,
+                    kind: ast::ConstItemKind::Body,
                     // test::TestDescAndFn {
-                    rhs_kind: ast::ConstItemRhsKind::new_body(
+                    body: Some(
                         cx.expr_struct(
                             sp,
                             test_path("TestDescAndFn"),