Auto merge of #162517 - khyperia:yeet-type-const, r=BoxyUwU

yeet `type const`



tracking issue: #132980

zulip thread context (design decussion of future of gca): [#project-const-generics > talkies at last @ 💬](https://rust-lang.zulipchat.com/#narrow/channel/260443-project-const-generics/topic/talkies.20at.20last/near/620368825)

this PR does two things:

- implement `#[rustc_always_gca]` (bikeshed name thread: [#project-const-generics > #[always_gca] bikeshed](https://rust-lang.zulipchat.com/#narrow/channel/260443-project-const-generics/topic/.23.5Balways_gca.5D.20bikeshed/with/622249110) )
- remove `type const` syntax

it also migrates the test suite to the syntax introduced in #162179 i.e. the new way to write `type const` is now `const ITEM: T = core::direct_const_arg!(V);` (ouch my hands, that took a while)

r? @BoxyUwU

Author: bors

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>>,