yeet type const

compiler/rustc_ast/src/ast.rs

@@ -4043,17 +4043,9 @@ pub struct ConstItem {
     pub generics: Generics,
     pub ty: Box<Ty>,
     pub body: Option<Box<Expr>>,
-    #[visitable(ignore)]
-    pub kind: ConstItemKind,
     pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
 }
 
-#[derive(Clone, Copy, Encodable, Decodable, Debug, PartialEq, Eq)]
-pub enum ConstItemKind {
-    Body,
-    TypeConst,
-}
-
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct ConstBlockItem {
     pub id: NodeId,

compiler/rustc_ast_lowering/src/item.rs

@@ -273,7 +273,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 generics,
                 ty,
                 body,
-                kind,
                 define_opaque,
             }) => {
                 let ident = self.lower_ident(*ident);
@@ -285,7 +284,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ty,
                             ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
                         );
-                        let rhs = this.lower_const_item_rhs(body, *kind, span);
+                        let rhs = this.lower_const_item_rhs(body, span);
                         (ty, rhs)
                     },
                 );
@@ -925,13 +924,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let (ident, generics, kind, has_value) = match &i.kind {
             AssocItemKind::Const(ConstItem {
-                ident,
-                generics,
-                ty,
-                body,
-                kind,
-                define_opaque,
-                ..
+                ident, generics, ty, body, define_opaque, ..
             }) => {
                 let (generics, kind) = self.lower_generics(
                     generics,
@@ -943,7 +936,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         );
                         // Trait associated consts don't need an expression/body.
                         let rhs = if body.is_some() {
-                            Some(this.lower_const_item_rhs(body, *kind, i.span))
+                            Some(this.lower_const_item_rhs(body, i.span))
                         } else {
                             None
                         };
@@ -1188,13 +1181,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let (ident, (generics, kind)) = match &i.kind {
             AssocItemKind::Const(ConstItem {
-                ident,
-                generics,
-                ty,
-                body,
-                kind,
-                define_opaque,
-                ..
+                ident, generics, ty, body, define_opaque, ..
             }) => (
                 *ident,
                 self.lower_generics(
@@ -1206,7 +1193,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
                         );
                         this.lower_define_opaque(hir_id, &define_opaque);
-                        let rhs = this.lower_const_item_rhs(body, *kind, i.span);
+                        let rhs = this.lower_const_item_rhs(body, i.span);
                         hir::ImplItemKind::Const(ty, rhs)
                     },
                 ),

compiler/rustc_ast_lowering/src/lib.rs

@@ -2682,56 +2682,31 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_const_item_rhs(
         &mut self,
         body: &Option<Box<Expr>>,
-        kind: ConstItemKind,
         span: Span,
     ) -> hir::ConstItemRhs<'hir> {
-        match (body, kind) {
-            (body, ConstItemKind::Body) => {
-                let is_direct = |body| {
-                    if self.tcx.features().macroless_const_item_generic_const_args() {
-                        self.can_lower_expr_to_const_arg_direct(
-                            body,
-                            DirectConstArgContext::MacrolessMinGenericConstArgs,
-                        )
-                        .is_ok()
-                    } else {
-                        // do not check can_lower_expr_to_const_arg_direct, but rather just
-                        // ExprKind::DirectConstArg, because we don't want e.g.
-                        // `impl<const N: u8> { const C: u8 = N; }` to be a direct-rhs const
-                        matches!(body, Expr { kind: ExprKind::DirectConstArg(_), .. })
-                    }
-                };
-                // N.B.: the feature gate for this is generic_const_args, not min_generic_const_args
-                if self.tcx.features().generic_const_args()
-                    && let Some(body) = body
-                    && is_direct(body)
-                {
-                    hir::ConstItemRhs::Direct(
-                        self.arena.alloc(self.lower_expr_to_const_arg_direct(&body, None)),
-                    )
-                } else {
-                    hir::ConstItemRhs::Body(self.lower_const_body(span, body.as_deref()))
-                }
-            }
-            (Some(body), ConstItemKind::TypeConst) => hir::ConstItemRhs::Direct(self.arena.alloc(
-                match self.can_lower_expr_to_const_arg_direct(
-                    &body,
+        let is_direct = |body| {
+            if self.tcx.features().macroless_const_item_generic_const_args() {
+                self.can_lower_expr_to_const_arg_direct(
+                    body,
                     DirectConstArgContext::MacrolessMinGenericConstArgs,
-                ) {
-                    Ok(()) => self.lower_expr_to_const_arg_direct(&body, None),
-                    Err(err) => err.emit(self),
-                },
-            )),
-            (None, ConstItemKind::TypeConst) => {
-                let const_arg = ConstArg {
-                    hir_id: self.next_id(),
-                    kind: hir::ConstArgKind::Error(
-                        self.dcx().span_delayed_bug(DUMMY_SP, "no block"),
-                    ),
-                    span: DUMMY_SP,
-                };
-                hir::ConstItemRhs::Direct(self.arena.alloc(const_arg))
+                )
+                .is_ok()
+            } else {
+                // do not check can_lower_expr_to_const_arg_direct, but rather just
+                // ExprKind::DirectConstArg, because we don't want e.g.
+                // `impl<const N: u8> { const C: u8 = N; }` to be a direct-rhs const
+                matches!(body, Expr { kind: ExprKind::DirectConstArg(_), .. })
             }
+        };
+        if self.tcx.features().min_generic_const_args()
+            && let Some(body) = body
+            && is_direct(body)
+        {
+            hir::ConstItemRhs::Direct(
+                self.arena.alloc(self.lower_expr_to_const_arg_direct(&body, None)),
+            )
+        } else {
+            hir::ConstItemRhs::Body(self.lower_const_body(span, body.as_deref()))
         }
     }
 

compiler/rustc_ast_lowering/src/path.rs

@@ -113,7 +113,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         }
                         // `a::b::Trait(Args)::TraitItem`
                         Res::Def(DefKind::AssocFn, _)
-                        | Res::Def(DefKind::AssocConst { .. }, _)
+                        | Res::Def(DefKind::AssocConst, _)
                         | Res::Def(DefKind::AssocTy, _)
                             if i + 2 == proj_start =>
                         {

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -190,13 +190,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::ItemKind::TyAlias(ast::TyAlias { ty: Some(ty), .. }) => {
                 self.check_impl_trait(ty, false)
             }
-            ast::ItemKind::Const(ast::ConstItem {
-                kind: ast::ConstItemKind::TypeConst, ..
-            }) => {
-                // Make sure this is only allowed if the feature gate is enabled.
-                // #![feature(min_generic_const_args)]
-                gate!(self, min_generic_const_args, i.span, "top-level `type const` are unstable");
-            }
 
             _ => {}
         }
@@ -364,18 +357,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 }
                 false
             }
-            ast::AssocItemKind::Const(ast::ConstItem {
-                body,
-                kind: ast::ConstItemKind::TypeConst,
-                ..
-            }) => {
-                // Make sure this is only allowed if the feature gate is enabled.
-                // #![feature(min_generic_const_args)]
-                gate!(self, min_generic_const_args, i.span, "associated `type const` are unstable");
-                // 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 && body.is_some() {
+            ast::AssocItemKind::Const(ast::ConstItem { body: Some(_), .. }) => {
+                if ctxt == AssocCtxt::Trait && attr::contains_name(&i.attrs, sym::rustc_always_gca)
+                {
                     gate!(
                         self,
                         associated_type_defaults,
@@ -511,25 +495,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
         gate!(visitor, min_generic_const_args, span, "associated const equality is incomplete");
     }
 
-    // `mgca_type_const_syntax` is part of `min_generic_const_args` so if
-    // either or both are enabled we don't need to emit a feature error.
-    for &span in spans.get(&sym::mgca_type_const_syntax).into_flat_iter() {
-        if visitor.features.min_generic_const_args()
-            || visitor.features.mgca_type_const_syntax()
-            || span.allows_unstable(sym::min_generic_const_args)
-            || span.allows_unstable(sym::mgca_type_const_syntax)
-        {
-            continue;
-        }
-        feature_err(
-            visitor.sess,
-            sym::min_generic_const_args,
-            span,
-            "`type const` syntax is experimental",
-        )
-        .emit();
-    }
-
     // Negative bounds are *super* internal. We require `-Zinternal-testing-features` *and*
     // `#![feature(negative_bounds)]` to prevent proliferation. Under no circumstances do we
     // want to advertise the flag and the feature name to users!

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

@@ -229,7 +229,6 @@ impl<'a> State<'a> {
                 generics,
                 ty,
                 body,
-                kind: _,
                 define_opaque,
             }) => {
                 self.print_item_const(
@@ -621,7 +620,6 @@ impl<'a> State<'a> {
                 generics,
                 ty,
                 body,
-                kind: _,
                 define_opaque,
             }) => {
                 self.print_item_const(

compiler/rustc_attr_ir/src/data_structures.rs

@@ -785,6 +785,9 @@ pub enum AttributeKind {
     /// Represents `#[allow_internal_unstable]`.
     AllowInternalUnstable(ThinVec<(Symbol, Span)>, Span),
 
+    /// Represents `#[rustc_always_gca]`
+    AlwaysGca,
+
     /// Represents `#[automatically_derived]`
     AutomaticallyDerived,
 

compiler/rustc_attr_ir/src/encode_cross_crate.rs

@@ -20,6 +20,7 @@ impl AttributeKind {
             // tidy-alphabetical-start
             AllowInternalUnsafe(..) => Yes,
             AllowInternalUnstable(..) => Yes,
+            AlwaysGca => Yes,
             AutomaticallyDerived => Yes,
             CfgAttrTrace(..) => Yes,
             CfgTrace(..) => Yes,

compiler/rustc_attr_parsing/src/attributes/semantics.rs

@@ -27,3 +27,12 @@ impl NoArgsAttributeParser for ComptimeParser {
     const STABILITY: AttributeStability = unstable!(rustc_attrs);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcComptime;
 }
+
+pub(crate) struct AlwaysGcaParser;
+impl NoArgsAttributeParser for AlwaysGcaParser {
+    const PATH: &[Symbol] = &[sym::rustc_always_gca];
+    const ALLOWED_TARGETS: AllowedTargets<'_> =
+        AllowedTargets::AllowList(&[Allow(Target::AssocConst(AssocCtxt::Trait))]);
+    const STABILITY: AttributeStability = unstable!(min_generic_const_args);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::AlwaysGca;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -259,6 +259,7 @@ attribute_parsers!(
         Single<UnrollParser>,
         Single<WindowsSubsystemParser>,
         Single<WithoutArgs<AllowInternalUnsafeParser>>,
+        Single<WithoutArgs<AlwaysGcaParser>>,
         Single<WithoutArgs<AutomaticallyDerivedParser>>,
         Single<WithoutArgs<ColdParser>>,
         Single<WithoutArgs<CompilerBuiltinsParser>>,

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1271,10 +1271,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
         let hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = base.kind else { return };
         let (hir::def::Res::Local(_)
         | hir::def::Res::Def(
-            DefKind::Const { .. }
-            | DefKind::ConstParam
-            | DefKind::Static { .. }
-            | DefKind::AssocConst { .. },
+            DefKind::Const | DefKind::ConstParam | DefKind::Static { .. } | DefKind::AssocConst,
             _,
         )) = path.res
         else {

compiler/rustc_borrowck/src/implied_bounds.rs

@@ -90,7 +90,7 @@ pub(super) fn mir_borrowck_implied_outlives_bounds<'tcx>(
     // - We must compute the normalized signature and then compute implied bounds from that
     //   in order to connect any unconstrained region vars created during normalization to
     //   the types of the locals corresponding to the inputs and outputs of the item. #136547
-    if matches!(tcx.def_kind(body_def_id), DefKind::AssocFn | DefKind::AssocConst { .. }) {
+    if matches!(tcx.def_kind(body_def_id), DefKind::AssocFn | DefKind::AssocConst) {
         for &(ty, _) in tcx.assumed_wf_types(tcx.local_parent(body_def_id)) {
             let normalized_ty = ocx
                 .deeply_normalize(

compiler/rustc_borrowck/src/type_check/free_region_relations.rs

@@ -296,8 +296,7 @@ impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
         // - We must compute the normalized signature and then compute implied bounds from that
         //   in order to connect any unconstrained region vars created during normalization to
         //   the types of the locals corresponding to the inputs and outputs of the item. (#136547)
-        if matches!(tcx.def_kind(defining_ty_def_id), DefKind::AssocFn | DefKind::AssocConst { .. })
-        {
+        if matches!(tcx.def_kind(defining_ty_def_id), DefKind::AssocFn | DefKind::AssocConst) {
             for &(ty, _) in tcx.assumed_wf_types(tcx.local_parent(defining_ty_def_id)) {
                 let result: Result<_, ErrorGuaranteed> = self
                     .infcx

compiler/rustc_builtin_macros/src/alloc_error_handler.rs

@@ -44,13 +44,8 @@ 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_item = ecx.item_const(
-        span,
-        Ident::new(kw::Underscore, span),
-        const_ty,
-        Some(const_body),
-        ast::ConstItemKind::Body,
-    );
+    let const_item =
+        ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, Some(const_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

@@ -351,13 +351,7 @@ fn generate_default_impl(
     let anon_mod = |span: Span, stmts: ThinVec<ast::Stmt>| {
         let unit = ecx.ty(item_span, ast::TyKind::Tup(ThinVec::new()));
         let underscore = Ident::new(kw::Underscore, item_span);
-        ecx.item_const(
-            span,
-            underscore,
-            unit,
-            Some(ecx.expr_block(ecx.block(span, stmts))),
-            ast::ConstItemKind::Body,
-        )
+        ecx.item_const(span, underscore, unit, Some(ecx.expr_block(ecx.block(span, stmts))))
     };
 
     // const _: () = {

compiler/rustc_builtin_macros/src/global_allocator.rs

@@ -55,13 +55,8 @@ 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_item = ecx.item_const(
-        span,
-        Ident::new(kw::Underscore, span),
-        const_ty,
-        Some(const_body),
-        ast::ConstItemKind::Body,
-    );
+    let const_item =
+        ecx.item_const(span, Ident::new(kw::Underscore, span), const_ty, Some(const_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

@@ -371,7 +371,6 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> Box<ast::Item> {
         Ident::new(kw::Underscore, span),
         cx.ty(span, ast::TyKind::Tup(ThinVec::new())),
         Some(block),
-        ast::ConstItemKind::Body,
     );
 
     // Integrate the new item into existing module structures.

compiler/rustc_builtin_macros/src/test.rs

@@ -282,7 +282,6 @@ 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 {
                     body: Some(
                         cx.expr_struct(