feature(const_generics) -> feature(const_param_types)

compiler/rustc_ast/src/ast.rs

@@ -332,7 +332,7 @@ pub type GenericBounds = Vec<GenericBound>;
 pub enum ParamKindOrd {
     Lifetime,
     Type,
-    // `unordered` is only `true` if `sess.has_features().const_generics`
+    // `unordered` is only `true` if `sess.has_features().const_generics_defaults`
     // is active. Specifically, if it's only `min_const_generics`, it will still require
     // ordering consts after types.
     Const { unordered: bool },

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -687,7 +687,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
     gate_all!(trait_alias, "trait aliases are experimental");
     gate_all!(associated_type_bounds, "associated type bounds are unstable");
     gate_all!(crate_visibility_modifier, "`crate` visibility modifier is experimental");
-    gate_all!(const_generics, "const generics are unstable");
     gate_all!(decl_macro, "`macro` is experimental");
     gate_all!(box_patterns, "box pattern syntax is experimental");
     gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");

compiler/rustc_error_codes/src/error_codes/E0671.md

@@ -4,8 +4,6 @@ Const parameters cannot depend on type parameters.
 The following is therefore invalid:
 
 ```compile_fail,E0770
-#![feature(const_generics)]
-
 fn const_id<T, const N: T>() -> T { // error
     N
 }

compiler/rustc_error_codes/src/error_codes/E0741.md

@@ -3,7 +3,7 @@ A non-structural-match type was used as the type of a const generic parameter.
 Erroneous code example:
 
 ```compile_fail,E0741
-#![feature(const_generics)]
+#![feature(const_param_types)]
 
 struct A;
 
@@ -16,7 +16,7 @@ may be used as the types of const generic parameters.
 To fix the previous code example, we derive `PartialEq` and `Eq`:
 
 ```
-#![feature(const_generics)]
+#![feature(const_param_types)]
 
 #[derive(PartialEq, Eq)] // We derive both traits here.
 struct A;

compiler/rustc_error_codes/src/error_codes/E0770.md

@@ -3,7 +3,6 @@ The type of a const parameter references other generic parameters.
 Erroneous code example:
 
 ```compile_fail,E0770
-#![feature(const_generics)]
 fn foo<T, const N: T>() {} // error!
 ```
 

compiler/rustc_error_codes/src/error_codes/E0771.md

@@ -4,7 +4,7 @@ allowed.
 Erroneous code example:
 
 ```compile_fail,E0771
-#![feature(const_generics)]
+#![feature(const_param_types)]
 
 fn function_with_str<'a, const STRING: &'a str>() {} // error!
 ```
@@ -13,7 +13,7 @@ To fix this issue, the lifetime in the const generic need to be changed to
 `'static`:
 
 ```
-#![feature(const_generics)]
+#![feature(const_param_types)]
 
 fn function_with_str<const STRING: &'static str>() {} // ok!
 ```

compiler/rustc_feature/src/accepted.rs

@@ -273,7 +273,7 @@ declare_features! (
     /// Allows patterns with concurrent by-move and by-ref bindings.
     /// For example, you can write `Foo(a, ref b)` where `a` is by-move and `b` is by-ref.
     (accepted, move_ref_pattern, "1.49.0", Some(68354), None),
-    /// The smallest useful subset of `const_generics`.
+    /// The smallest useful subset of const generics.
     (accepted, min_const_generics, "1.51.0", Some(74878), None),
     /// The `unsafe_op_in_unsafe_fn` lint (allowed by default): no longer treat an unsafe function as an unsafe block.
     (accepted, unsafe_block_in_unsafe_fn, "1.52.0", Some(71668), None),

compiler/rustc_feature/src/active.rs

@@ -71,7 +71,7 @@ macro_rules! declare_features {
             }
 
             pub fn unordered_const_ty_params(&self) -> bool {
-                self.const_generics || self.const_generics_defaults
+                self.const_generics_defaults
             }
 
             /// Some features are known to be incomplete and using them is likely to have
@@ -453,9 +453,6 @@ declare_features! (
     /// Allows using `#[ffi_returns_twice]` on foreign functions.
     (active, ffi_returns_twice, "1.34.0", Some(58314), None),
 
-    /// Allows const generic types (e.g. `struct Foo<const N: usize>(...);`).
-    (incomplete, const_generics, "1.34.0", Some(44580), None),
-
     /// Allows using `#[optimize(X)]`.
     (active, optimize_attribute, "1.34.0", Some(54882), None),
 
@@ -676,6 +673,9 @@ declare_features! (
     /// Allows non-trivial generic constants which have to have wfness manually propagated to callers
     (incomplete, generic_const_exprs, "1.56.0", Some(76560), None),
 
+    /// Allows additional const parameter types, such as `&'static str` or user defined types
+    (incomplete, const_param_types, "1.56.0", Some(44580), None),
+
     // -------------------------------------------------------------------------
     // feature-group-end: actual feature gates
     // -------------------------------------------------------------------------

compiler/rustc_feature/src/removed.rs

@@ -102,6 +102,9 @@ declare_features! (
     (removed, extern_in_paths, "1.33.0", Some(55600), None,
      Some("subsumed by `::foo::bar` paths")),
     (removed, quote, "1.33.0", Some(29601), None, None),
+    /// Allows const generic types (e.g. `struct Foo<const N: usize>(...);`).
+    (removed, const_generics, "1.34.0", Some(44580), None,
+     Some("removed in favor of `#![feature(const_param_types]` and `#![feature(generic_const_exprs)]`")),
     /// Allows `[x; N]` where `x` is a constant (RFC 2203).
     (removed, const_in_array_repeat_expressions,  "1.37.0", Some(49147), None,
      Some("removed due to causing promotable bugs")),

compiler/rustc_infer/src/infer/combine.rs

@@ -202,7 +202,7 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
     /// A good example of this is the following:
     ///
     /// ```rust
-    /// #![feature(const_generics)]
+    /// #![feature(generic_const_exprs)]
     ///
     /// fn bind<const N: usize>(value: [u8; N]) -> [u8; 3 + 4] {
     ///     todo!()

compiler/rustc_lint/src/builtin.rs

@@ -2340,7 +2340,7 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust
-    /// #![feature(const_generics)]
+    /// #![feature(generic_const_exprs)]
     /// ```
     ///
     /// {{produces}}

compiler/rustc_middle/src/ty/context.rs

@@ -1420,8 +1420,8 @@ impl<'tcx> TyCtxt<'tcx> {
     #[inline]
     pub fn lazy_normalization(self) -> bool {
         let features = self.features();
-        // Note: We do not enable lazy normalization for `min_const_generics`.
+        // Note: We only use lazy normalization for generic const expressions.
-        features.const_generics || features.generic_const_exprs
+        features.generic_const_exprs
     }
 
     #[inline]

compiler/rustc_resolve/src/diagnostics.rs

@@ -506,8 +506,7 @@ impl<'a> Resolver<'a> {
 
                 if self.session.is_nightly_build() {
                     err.help(
-                        "use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` \
+                        "use `#![feature(generic_const_exprs)]` to allow generic const expressions",
-                        to allow generic const expressions",
                     );
                 }
 

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -2245,7 +2245,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
     }
 
     /// Non-static lifetimes are prohibited in anonymous constants under `min_const_generics`.
-    /// This function will emit an error if `const_generics` is not enabled, the body identified by
+    /// This function will emit an error if `generic_const_exprs` is not enabled, the body identified by
     /// `body_id` is an anonymous constant and `lifetime_ref` is non-static.
     crate fn maybe_emit_forbidden_non_static_lifetime_error(
         &self,
@@ -2264,7 +2264,7 @@ impl<'tcx> LifetimeContext<'_, 'tcx> {
         if !self.tcx.lazy_normalization() && is_anon_const && !is_allowed_lifetime {
             feature_err(
                 &self.tcx.sess.parse_sess,
-                sym::const_generics,
+                sym::generic_const_exprs,
                 lifetime_ref.span,
                 "a non-static lifetime is not allowed in a `const`",
             )

compiler/rustc_resolve/src/late/lifetimes.rs

@@ -2301,7 +2301,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
             match *scope {
                 Scope::Body { id, s } => {
                     // Non-static lifetimes are prohibited in anonymous constants without
-                    // `const_generics`.
+                    // `generic_const_exprs`.
                     self.maybe_emit_forbidden_non_static_lifetime_error(id, lifetime_ref);
 
                     outermost_body = Some(id);

compiler/rustc_resolve/src/lib.rs

@@ -2734,8 +2734,7 @@ impl<'a> Resolver<'a> {
                         ConstantItemRibKind(trivial, _) => {
                             let features = self.session.features_untracked();
                             // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
-                            if !(trivial || features.const_generics || features.generic_const_exprs)
+                            if !(trivial || features.generic_const_exprs) {
-                            {
                                 // HACK(min_const_generics): If we encounter `Self` in an anonymous constant
                                 // we can't easily tell if it's generic at this stage, so we instead remember
                                 // this and then enforce the self type to be concrete later on.
@@ -2807,8 +2806,7 @@ impl<'a> Resolver<'a> {
                         ConstantItemRibKind(trivial, _) => {
                             let features = self.session.features_untracked();
                             // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
-                            if !(trivial || features.const_generics || features.generic_const_exprs)
+                            if !(trivial || features.generic_const_exprs) {
-                            {
                                 if record_used {
                                     self.report_error(
                                         span,

compiler/rustc_span/src/symbol.rs

@@ -451,6 +451,7 @@ symbols! {
         const_mut_refs,
         const_panic,
         const_panic_fmt,
+        const_param_types,
         const_precise_live_drops,
         const_ptr,
         const_raw_ptr_deref,

compiler/rustc_typeck/src/check/wfcheck.rs

@@ -290,7 +290,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
 
             let err_ty_str;
             let mut is_ptr = true;
-            let err = if tcx.features().const_generics {
+            let err = if tcx.features().const_param_types {
                 match ty.peel_refs().kind() {
                     ty::FnPtr(_) => Some("function pointers"),
                     ty::RawPtr(_) => Some("raw pointers"),
@@ -328,7 +328,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) {
                     err.note("the only supported types are integers, `bool` and `char`");
                     if tcx.sess.is_nightly_build() {
                         err.help(
-                            "more complex types are supported with `#![feature(const_generics)]`",
+                            "more complex types are supported with `#![feature(const_param_types)]`",
                         );
                     }
                     err.emit()

compiler/rustc_typeck/src/collect.rs

@@ -1489,7 +1489,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
                 }
 
                 // HACK(eddyb) this provides the correct generics when
-                // `feature(const_generics)` is enabled, so that const expressions
+                // `feature(generic_const_expressions)` is enabled, so that const expressions
                 // used with const generics, e.g. `Foo<{N+1}>`, can work at all.
                 //
                 // Note that we do not supply the parent generics when using

src/test/debuginfo/function-names.rs

@@ -82,8 +82,8 @@
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
-#![feature(const_generics, generators, generator_trait)]
+#![feature(const_param_types, generators, generator_trait)]
-#![allow(incomplete_features)] // for const_generics
+#![allow(incomplete_features)]
 
 use Mod1::TestTrait2;
 use std::ops::Generator;

src/test/incremental/const-generics/hash-tyvid-regression-1.rs

@@ -1,5 +1,5 @@
 // revisions: cfail
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs, const_param_types)]
 #![allow(incomplete_features)]
 // regression test for #77650
 fn c<T, const N: std::num::NonZeroUsize>()

src/test/incremental/const-generics/hash-tyvid-regression-1.stderr

@@ -1,35 +0,0 @@
-error[E0277]: the trait bound `[T; _]: From<()>` is not satisfied
-  --> $DIR/hash-tyvid-regression-1.rs:9:5
-   |
-LL |     <[T; N.get()]>::try_from(())
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `From<()>` is not implemented for `[T; _]`
-   |
-   = note: required because of the requirements on the impl of `Into<[T; _]>` for `()`
-   = note: required because of the requirements on the impl of `TryFrom<()>` for `[T; _]`
-note: required by `try_from`
-  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
-   |
-LL |     fn try_from(value: T) -> Result<Self, Self::Error>;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0308]: mismatched types
-  --> $DIR/hash-tyvid-regression-1.rs:9:5
-   |
-LL |     <[T; N.get()]>::try_from(())
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found enum `Result`
-   |
-   = note: expected unit type `()`
-                   found enum `Result<[T; _], Infallible>`
-help: consider using a semicolon here
-   |
-LL |     <[T; N.get()]>::try_from(());
-   |                                 +
-help: try adding a return type
-   |
-LL | -> Result<[T; _], Infallible> where
-   | +++++++++++++++++++++++++++++
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0277, E0308.
-For more information about an error, try `rustc --explain E0277`.

src/test/incremental/const-generics/hash-tyvid-regression-2.rs

@@ -1,5 +1,5 @@
 // revisions: cfail
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs, const_param_types, const_generics_defaults)]
 #![allow(incomplete_features)]
 // regression test for #77650
 struct C<T, const N: core::num::NonZeroUsize>([T; N.get()])

src/test/incremental/const-generics/hash-tyvid-regression-2.stderr

@@ -1,11 +0,0 @@
-error[E0277]: can't compare `[B; _]` with `&&[A]`
-  --> $DIR/hash-tyvid-regression-2.rs:12:16
-   |
-LL |         self.0 == other
-   |                ^^ no implementation for `[B; _] == &&[A]`
-   |
-   = help: the trait `PartialEq<&&[A]>` is not implemented for `[B; _]`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0277`.

src/test/incremental/const-generics/hash-tyvid-regression-3.rs

@@ -1,5 +1,5 @@
 // revisions: cfail
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 // regression test for #79251
 struct Node<const D: usize>

src/test/incremental/const-generics/hash-tyvid-regression-3.stderr

@@ -1,12 +0,0 @@
-error[E0599]: no method named `some_function` found for struct `SmallVec` in the current scope
-  --> $DIR/hash-tyvid-regression-3.rs:17:19
-   |
-LL |         node.keys.some_function();
-   |                   ^^^^^^^^^^^^^ method not found in `SmallVec<{ D * 2 }>`
-...
-LL | struct SmallVec<const D: usize> {}
-   | ------------------------------- method `some_function` not found for this
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0599`.

src/test/incremental/const-generics/hash-tyvid-regression-4.rs

@@ -1,5 +1,5 @@
 // revisions: cfail
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 // regression test for #79251
 #[derive(Debug)]

src/test/incremental/const-generics/hash-tyvid-regression-4.stderr

@@ -1,12 +0,0 @@
-error[E0599]: no method named `push` found for struct `SmallVec` in the current scope
-  --> $DIR/hash-tyvid-regression-4.rs:23:19
-   |
-LL |         node.keys.push(k);
-   |                   ^^^^ method not found in `SmallVec<_, { D * 2 }>`
-...
-LL | struct SmallVec<T, const D: usize> {
-   | ---------------------------------- method `push` not found for this
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0599`.

src/test/incremental/const-generics/issue-61338.rs

@@ -1,7 +1,5 @@
 // revisions:rpass1
 
-#![feature(const_generics)]
-
 struct Struct<T>(T);
 
 impl<T, const N: usize> Struct<[T; N]> {

src/test/incremental/const-generics/issue-61516.rs

@@ -1,7 +1,5 @@
 // revisions:rpass1
 
-#![feature(const_generics)]
-
 struct FakeArray<T, const N: usize>(T);
 
 impl<T, const N: usize> FakeArray<T, N> {

src/test/incremental/const-generics/issue-62536.rs

@@ -1,7 +1,4 @@
 // revisions:cfail1
-#![feature(const_generics)]
-//[cfail1]~^ WARN the feature `const_generics` is incomplete
-
 struct S<T, const N: usize>([T; N]);
 
 fn f<T, const N: usize>(x: T) -> S<T, {N}> { panic!() }

src/test/incremental/const-generics/issue-64087.rs

@@ -1,6 +1,4 @@
 // revisions:cfail1
-#![feature(const_generics)]
-//[cfail1]~^ WARN the feature `const_generics` is incomplete
 
 fn combinator<T, const S: usize>() -> [T; S] {}
 //[cfail1]~^ ERROR mismatched types

src/test/incremental/const-generics/issue-65623.rs

@@ -1,6 +1,4 @@
 // revisions:rpass1
-#![feature(const_generics)]
-
 pub struct Foo<T, const N: usize>([T; 0]);
 
 impl<T, const N: usize> Foo<T, {N}> {

src/test/incremental/const-generics/issue-68477.rs

@@ -1,6 +1,8 @@
 // edition:2018
 // revisions:rpass1
-#![feature(const_generics)]
+
+// Needed to supply generic arguments to the anon const in `[(); FOO]`.
+#![feature(generic_const_exprs)]
 
 const FOO: usize = 1;
 

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-77708-1.rs

@@ -1,5 +1,5 @@
 // revisions: cfail
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features, unused_braces)]
 
 trait Delegates<T> {}

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-77708-2.rs

@@ -1,5 +1,5 @@
 // revisions: rpass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 struct Z;

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-77708-3.rs

@@ -1,5 +1,5 @@
 // revisions: rpass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs, const_param_types)]
 #![allow(incomplete_features)]
 
 use std::{convert::TryFrom, num::NonZeroUsize};

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-82034.rs

@@ -1,5 +1,5 @@
 // revisions: rpass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 pub trait IsTrue {}
 pub trait IsFalse {}

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-85031-1.rs

@@ -1,5 +1,5 @@
 // revisions: rpass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 pub struct Ref<'a, const NUM: usize>(&'a i32);

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-85031-2.rs

@@ -1,6 +1,6 @@
 // revisions: cfail
 #![allow(incomplete_features)]
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 
 pub struct Ref<'a>(&'a i32);
 

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-85031-3.rs

@@ -1,5 +1,5 @@
 // revisions: rpass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 fn test<const SIZE: usize>() {}

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-86953.rs

@@ -1,5 +1,5 @@
 // revisions: rpass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 struct Foo;

src/test/incremental/const-generics/try_unify_abstract_const_regression_tests/issue-88022.rs

@@ -1,5 +1,5 @@
 // revisions: cfail
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features, unused_braces)]
 
 struct Buffer<T, const S: usize>

src/test/rustdoc/const-generics/add-impl.rs

@@ -1,4 +1,3 @@
-#![feature(const_generics)]
 #![crate_name = "foo"]
 
 use std::ops::Add;

src/test/rustdoc/const-generics/const-generic-slice.rs

@@ -1,5 +1,4 @@
 #![crate_name = "foo"]
-#![feature(const_generics)]
 
 pub trait Array {
     type Item;

src/test/rustdoc/const-generics/const-impl.rs

@@ -1,4 +1,4 @@
-#![feature(const_generics)]
+#![feature(const_param_types)]
 
 #![crate_name = "foo"]
 

src/test/rustdoc/const-generics/generic_const_exprs.rs

@@ -1,5 +1,5 @@
 #![crate_name = "foo"]
-#![feature(generic_const_exprs, const_generics)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 // make sure that `ConstEvaluatable` predicates dont cause rustdoc to ICE #77647
 // @has foo/struct.Ice.html '//pre[@class="rust struct"]' \

src/test/rustdoc/const-generics/lazy_normalization_consts/const-equate-pred.rs

@@ -1,5 +1,5 @@
 #![crate_name = "foo"]
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 // Checking if `Send` is implemented for `Hasher` requires us to evaluate a `ConstEquate` predicate,

src/test/ui/array-slice-vec/match_arr_unknown_len.rs

@@ -1,6 +1,3 @@
-#![feature(const_generics)]
-//~^ WARN the feature `const_generics` is incomplete
-
 fn is_123<const N: usize>(x: [u32; N]) -> bool {
     match x {
         [1, 2] => true, //~ ERROR mismatched types

src/test/ui/array-slice-vec/match_arr_unknown_len.stderr

@@ -1,14 +1,5 @@
-warning: the feature `const_generics` is incomplete and may not be safe to use and/or cause compiler crashes
-  --> $DIR/match_arr_unknown_len.rs:1:12
-   |
-LL | #![feature(const_generics)]
-   |            ^^^^^^^^^^^^^^
-   |
-   = note: `#[warn(incomplete_features)]` on by default
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
-
 error[E0308]: mismatched types
-  --> $DIR/match_arr_unknown_len.rs:6:9
+  --> $DIR/match_arr_unknown_len.rs:3:9
    |
 LL |         [1, 2] => true,
    |         ^^^^^^ expected `2_usize`, found `N`
@@ -16,6 +7,6 @@ LL |         [1, 2] => true,
    = note: expected array `[u32; 2]`
               found array `[u32; N]`
 
-error: aborting due to previous error; 1 warning emitted
+error: aborting due to previous error
 
 For more information about this error, try `rustc --explain E0308`.

src/test/ui/associated-consts/associated-const-type-parameter-arrays.stderr

@@ -5,7 +5,7 @@ LL |     let _array: [u32; <A as Foo>::Y];
    |                        ^ cannot perform const operation using `A`
    |
    = note: type parameters may not be used in const expressions
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: aborting due to previous error
 

src/test/ui/associated-item/associated-item-duplicate-bounds.stderr

@@ -5,7 +5,7 @@ LL |     links: [u32; A::LINKS], // Shouldn't suggest bounds already there.
    |                  ^^^^^^^^ cannot perform const operation using `A`
    |
    = note: type parameters may not be used in const expressions
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: aborting due to previous error
 

src/test/ui/async-await/issues/issue-78654.rs

@@ -1,7 +1,7 @@
 // edition:2018
 // revisions: full min
 
-#![cfg_attr(full, feature(const_generics))]
+#![cfg_attr(full, feature(const_param_types))]
 #![cfg_attr(full, allow(incomplete_features))]
 
 struct Foo;

src/test/ui/binding/const-param.min.stderr

@@ -1,9 +0,0 @@
-error[E0158]: const parameters cannot be referenced in patterns
-  --> $DIR/const-param.rs:8:9
-   |
-LL |         N => {}
-   |         ^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0158`.

src/test/ui/binding/const-param.rs

@@ -1,7 +1,4 @@
 // Identifier pattern referring to a const generic parameter is an error (issue #68853).
-// revisions: full min
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 fn check<const N: usize>() {
     match 1 {

src/test/ui/binding/const-param.stderr

@@ -1,5 +1,5 @@
 error[E0158]: const parameters cannot be referenced in patterns
-  --> $DIR/const-param.rs:8:9
+  --> $DIR/const-param.rs:5:9
    |
 LL |         N => {}
    |         ^

src/test/ui/const-generics/apit-with-const-param.rs

@@ -1,8 +1,4 @@
 // check-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 trait Trait {}
 

src/test/ui/const-generics/argument_order.full.stderr

@@ -1,11 +1,11 @@
 error: lifetime parameters must be declared prior to const parameters
-  --> $DIR/argument_order.rs:11:32
+  --> $DIR/argument_order.rs:10:32
    |
 LL | struct AlsoBad<const N: usize, 'a, T, 'b, const M: usize, U> {
    |               -----------------^^-----^^-------------------- help: reorder the parameters: lifetimes, then consts and types: `<'a, 'b, const N: usize, T, const M: usize, U>`
 
 error[E0747]: lifetime provided when a type was expected
-  --> $DIR/argument_order.rs:19:23
+  --> $DIR/argument_order.rs:18:23
    |
 LL |     let _: AlsoBad<7, 'static, u32, 'static, 17, u16>;
    |                       ^^^^^^^

src/test/ui/const-generics/argument_order.min.stderr

@@ -1,23 +1,23 @@
 error: type parameters must be declared prior to const parameters
-  --> $DIR/argument_order.rs:5:28
+  --> $DIR/argument_order.rs:4:28
    |
 LL | struct Bad<const N: usize, T> {
    |           -----------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const N: usize>`
 
 error: lifetime parameters must be declared prior to const parameters
-  --> $DIR/argument_order.rs:11:32
+  --> $DIR/argument_order.rs:10:32
    |
 LL | struct AlsoBad<const N: usize, 'a, T, 'b, const M: usize, U> {
    |               -----------------^^-----^^-------------------- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T, U, const N: usize, const M: usize>`
 
 error: type parameters must be declared prior to const parameters
-  --> $DIR/argument_order.rs:11:36
+  --> $DIR/argument_order.rs:10:36
    |
 LL | struct AlsoBad<const N: usize, 'a, T, 'b, const M: usize, U> {
    |               ---------------------^----------------------^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, 'b, T, U, const N: usize, const M: usize>`
 
 error[E0747]: lifetime provided when a type was expected
-  --> $DIR/argument_order.rs:19:23
+  --> $DIR/argument_order.rs:18:23
    |
 LL |     let _: AlsoBad<7, 'static, u32, 'static, 17, u16>;
    |                       ^^^^^^^

src/test/ui/const-generics/argument_order.rs

@@ -1,6 +1,5 @@
 // revisions: full min
-#![cfg_attr(full, feature(const_generics))]
+#![cfg_attr(full, feature(const_generics_defaults))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 struct Bad<const N: usize, T> {
     //[min]~^ ERROR type parameters must be declared prior to const parameters

src/test/ui/const-generics/array-size-in-generic-struct-param.full.stderr

@@ -1,18 +0,0 @@
-error: constant expression depends on a generic parameter
-  --> $DIR/array-size-in-generic-struct-param.rs:8:38
-   |
-LL | struct ArithArrayLen<const N: usize>([u32; 0 + N]);
-   |                                      ^^^^^^^^^^^^
-   |
-   = note: this may fail depending on what value the parameter takes
-
-error: constant expression depends on a generic parameter
-  --> $DIR/array-size-in-generic-struct-param.rs:19:10
-   |
-LL |     arr: [u8; CFG.arr_size],
-   |          ^^^^^^^^^^^^^^^^^^
-   |
-   = note: this may fail depending on what value the parameter takes
-
-error: aborting due to 2 previous errors
-

src/test/ui/const-generics/array-wrapper-struct-ctor.rs

@@ -1,7 +1,4 @@
 // run-pass
-// revisions: full min
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 #![allow(dead_code)]
 

src/test/ui/const-generics/associated-type-bound-fail.min.stderr

@@ -1,17 +0,0 @@
-error[E0277]: the trait bound `u16: Bar<N>` is not satisfied
-  --> $DIR/associated-type-bound-fail.rs:13:5
-   |
-LL |     type Assoc = u16;
-   |     ^^^^^^^^^^^^^^^^^ the trait `Bar<N>` is not implemented for `u16`
-   |
-   = help: the following implementations were found:
-             <u16 as Bar<3_usize>>
-note: required by a bound in `Foo::Assoc`
-  --> $DIR/associated-type-bound-fail.rs:8:17
-   |
-LL |     type Assoc: Bar<N>;
-   |                 ^^^^^^ required by this bound in `Foo::Assoc`
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0277`.

src/test/ui/const-generics/associated-type-bound-fail.rs

@@ -1,7 +1,3 @@
-// revisions: full min
-#![cfg_attr(full, allow(incomplete_features))]
-#![cfg_attr(full, feature(const_generics))]
-
 trait Bar<const N: usize> {}
 
 trait Foo<const N: usize> {

src/test/ui/const-generics/associated-type-bound-fail.stderr

@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `u16: Bar<N>` is not satisfied
-  --> $DIR/associated-type-bound-fail.rs:13:5
+  --> $DIR/associated-type-bound-fail.rs:9:5
    |
 LL |     type Assoc = u16;
    |     ^^^^^^^^^^^^^^^^^ the trait `Bar<N>` is not implemented for `u16`
@@ -7,7 +7,7 @@ LL |     type Assoc = u16;
    = help: the following implementations were found:
              <u16 as Bar<3_usize>>
 note: required by a bound in `Foo::Assoc`
-  --> $DIR/associated-type-bound-fail.rs:8:17
+  --> $DIR/associated-type-bound-fail.rs:4:17
    |
 LL |     type Assoc: Bar<N>;
    |                 ^^^^^^ required by this bound in `Foo::Assoc`

src/test/ui/const-generics/associated-type-bound.rs

@@ -1,8 +1,4 @@
 // run-pass
-// revisions: full min
-#![cfg_attr(full, allow(incomplete_features))]
-#![cfg_attr(full, feature(const_generics))]
-
 trait Bar<const N: usize> {}
 
 trait Foo<const N: usize> {

src/test/ui/const-generics/auxiliary/const_generic_lib.rs

@@ -1,6 +1,3 @@
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
-
 pub struct Struct<const N: usize>(pub [u8; N]);
 
 pub type Alias = Struct<2>;

src/test/ui/const-generics/auxiliary/crayte.rs

@@ -1,6 +1,4 @@
 // edition:2018
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 pub trait Foo<const N: usize> {}
 struct Local;

src/test/ui/const-generics/auxiliary/generics_of_parent.rs

@@ -1,4 +1,4 @@
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 // library portion of regression test for #87674

src/test/ui/const-generics/auxiliary/generics_of_parent_impl_trait.rs

@@ -1,4 +1,4 @@
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 // library portion of testing that `impl Trait<{ expr }>` doesnt

src/test/ui/const-generics/broken-mir-1.rs

@@ -1,9 +1,4 @@
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
-
 pub trait Foo {
     fn foo(&self);
 }

src/test/ui/const-generics/broken-mir-2.rs

@@ -1,9 +1,4 @@
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
-
 use std::fmt::Debug;
 
 #[derive(Debug)]

src/test/ui/const-generics/cannot-infer-type-for-const-param.rs

@@ -1,7 +1,4 @@
 // check-pass
-// revisions: full min
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 // This test confirms that the types can be inferred correctly for this example with const
 // generics. Previously this would ICE, and more recently error.

src/test/ui/const-generics/closing-args-token.min.stderr

@@ -1,52 +0,0 @@
-error: expressions must be enclosed in braces to be used as const generic arguments
-  --> $DIR/closing-args-token.rs:10:9
-   |
-LL |     S::<5 + 2 >> 7>;
-   |         ^^^^^
-   |
-help: enclose the `const` expression in braces
-   |
-LL |     S::<{ 5 + 2 } >> 7>;
-   |         +       +
-
-error: comparison operators cannot be chained
-  --> $DIR/closing-args-token.rs:10:16
-   |
-LL |     S::<5 + 2 >> 7>;
-   |                ^  ^
-   |
-help: split the comparison into two
-   |
-LL |     S::<5 + 2 >> 7 && 7>;
-   |                    ++++
-
-error: comparison operators cannot be chained
-  --> $DIR/closing-args-token.rs:16:20
-   |
-LL |     S::<{ 5 + 2 } >> 7>;
-   |                    ^  ^
-   |
-help: split the comparison into two
-   |
-LL |     S::<{ 5 + 2 } >> 7 && 7>;
-   |                        ++++
-
-error: expected expression, found `;`
-  --> $DIR/closing-args-token.rs:21:16
-   |
-LL |     T::<0 >= 3>;
-   |                ^ expected expression
-
-error: comparison operators cannot be chained
-  --> $DIR/closing-args-token.rs:27:12
-   |
-LL |     T::<x >>= 2 > 0>;
-   |            ^^   ^
-   |
-help: split the comparison into two
-   |
-LL |     T::<x >>= 2 && 2 > 0>;
-   |                 ++++
-
-error: aborting due to 5 previous errors
-

src/test/ui/const-generics/coerce_unsized_array.rs

@@ -1,9 +1,4 @@
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
-
 fn foo<const N: usize>(v: &[u8; N]) -> &[u8] {
     v
 }

src/test/ui/const-generics/concrete-const-as-fn-arg.rs

@@ -1,9 +1,5 @@
 // Test that a concrete const type i.e. A<2>, can be used as an argument type in a function
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 struct A<const N: usize>; // ok
 

src/test/ui/const-generics/concrete-const-impl-method.rs

@@ -1,10 +1,6 @@
 // Test that a method/associated non-method within an impl block of a concrete const type i.e. A<2>,
 // is callable.
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 pub struct A<const N: u32>;
 

src/test/ui/const-generics/condition-in-trait-const-arg.rs

@@ -2,7 +2,7 @@
 // run-pass
 // revisions: full min
 
-#![cfg_attr(full, feature(const_generics))]
+#![cfg_attr(full, feature(generic_const_exprs))]
 #![cfg_attr(full, allow(incomplete_features))]
 
 trait IsZeroTrait<const IS_ZERO: bool>{}

src/test/ui/const-generics/conservative_is_privately_uninhabited_uses_correct_param_env-1.rs

@@ -1,5 +1,5 @@
 // run-pass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 // This tests that the `conservative_is_privately_uninhabited` fn doesn't cause

src/test/ui/const-generics/conservative_is_privately_uninhabited_uses_correct_param_env-2.rs

@@ -1,5 +1,5 @@
 // run-pass
-#![feature(const_generics, generic_const_exprs)]
+#![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
 // This tests that the `conservative_is_privately_uninhabited` fn doesn't cause

src/test/ui/const-generics/const-arg-in-const-arg.min.stderr

@@ -5,7 +5,7 @@ LL |     let _: [u8; foo::<T>()];
    |                       ^ cannot perform const operation using `T`
    |
    = note: type parameters may not be used in const expressions
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: generic parameters may not be used in const operations
   --> $DIR/const-arg-in-const-arg.rs:14:23
@@ -14,7 +14,7 @@ LL |     let _: [u8; bar::<N>()];
    |                       ^ cannot perform const operation using `N`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `N`
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: generic parameters may not be used in const operations
   --> $DIR/const-arg-in-const-arg.rs:24:23
@@ -23,7 +23,7 @@ LL |     let _ = [0; bar::<N>()];
    |                       ^ cannot perform const operation using `N`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `N`
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: generic parameters may not be used in const operations
   --> $DIR/const-arg-in-const-arg.rs:29:24
@@ -32,7 +32,7 @@ LL |     let _: Foo<{ foo::<T>() }>;
    |                        ^ cannot perform const operation using `T`
    |
    = note: type parameters may not be used in const expressions
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: generic parameters may not be used in const operations
   --> $DIR/const-arg-in-const-arg.rs:30:24
@@ -41,7 +41,7 @@ LL |     let _: Foo<{ bar::<N>() }>;
    |                        ^ cannot perform const operation using `N`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `N`
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: generic parameters may not be used in const operations
   --> $DIR/const-arg-in-const-arg.rs:35:27
@@ -50,7 +50,7 @@ LL |     let _ = Foo::<{ foo::<T>() }>;
    |                           ^ cannot perform const operation using `T`
    |
    = note: type parameters may not be used in const expressions
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error: generic parameters may not be used in const operations
   --> $DIR/const-arg-in-const-arg.rs:36:27
@@ -59,7 +59,7 @@ LL |     let _ = Foo::<{ bar::<N>() }>;
    |                           ^ cannot perform const operation using `N`
    |
    = help: const parameters may only be used as standalone arguments, i.e. `N`
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:15:23
@@ -67,8 +67,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: [u8; faz::<'a>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:16:23
@@ -76,8 +76,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: [u8; baz::<'a>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:17:23
@@ -85,8 +85,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: [u8; faz::<'b>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:18:23
@@ -94,8 +94,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: [u8; baz::<'b>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:25:23
@@ -103,8 +103,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = [0; faz::<'a>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:26:23
@@ -112,8 +112,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = [0; baz::<'a>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:27:23
@@ -121,8 +121,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = [0; faz::<'b>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:28:23
@@ -130,8 +130,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = [0; baz::<'b>(&())];
    |                       ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:31:24
@@ -139,8 +139,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: Foo<{ faz::<'a>(&()) }>;
    |                        ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:32:24
@@ -148,8 +148,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: Foo<{ baz::<'a>(&()) }>;
    |                        ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:33:24
@@ -157,8 +157,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: Foo<{ faz::<'b>(&()) }>;
    |                        ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:34:24
@@ -166,8 +166,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _: Foo<{ baz::<'b>(&()) }>;
    |                        ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:37:27
@@ -175,8 +175,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = Foo::<{ faz::<'a>(&()) }>;
    |                           ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:38:27
@@ -184,8 +184,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = Foo::<{ baz::<'a>(&()) }>;
    |                           ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:39:27
@@ -193,8 +193,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = Foo::<{ faz::<'b>(&()) }>;
    |                           ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error[E0658]: a non-static lifetime is not allowed in a `const`
   --> $DIR/const-arg-in-const-arg.rs:40:27
@@ -202,8 +202,8 @@ error[E0658]: a non-static lifetime is not allowed in a `const`
 LL |     let _ = Foo::<{ baz::<'b>(&()) }>;
    |                           ^^
    |
-   = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
-   = help: add `#![feature(const_generics)]` to the crate attributes to enable
+   = help: add `#![feature(generic_const_exprs)]` to the crate attributes to enable
 
 error: aborting due to 23 previous errors
 

src/test/ui/const-generics/const-arg-in-const-arg.rs

@@ -1,5 +1,5 @@
 // revisions: min
-// FIXME(const_generics): This test currently causes an ICE because
+// FIXME(generic_const_exprs): This test currently causes an ICE because
 // we don't yet correctly deal with lifetimes, reenable this test once
 // this is fixed.
 

src/test/ui/const-generics/const-arg-in-fn.rs

@@ -1,9 +1,4 @@
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
-
 fn const_u32_identity<const X: u32>() -> u32 {
     X
 }

src/test/ui/const-generics/const-arg-type-arg-misordered.full.stderr

@@ -1,9 +0,0 @@
-error[E0747]: constant provided when a type was expected
-  --> $DIR/const-arg-type-arg-misordered.rs:7:35
-   |
-LL | fn foo<const N: usize>() -> Array<N, ()> {
-   |                                   ^
-
-error: aborting due to previous error
-
-For more information about this error, try `rustc --explain E0747`.

src/test/ui/const-generics/const-arg-type-arg-misordered.rs

@@ -1,7 +1,3 @@
-// revisions: full min
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
-
 type Array<T, const N: usize> = [T; N];
 
 fn foo<const N: usize>() -> Array<N, ()> {

src/test/ui/const-generics/const-arg-type-arg-misordered.stderr

@@ -1,5 +1,5 @@
 error[E0747]: constant provided when a type was expected
-  --> $DIR/const-arg-type-arg-misordered.rs:7:35
+  --> $DIR/const-arg-type-arg-misordered.rs:3:35
    |
 LL | fn foo<const N: usize>() -> Array<N, ()> {
    |                                   ^

src/test/ui/const-generics/const-argument-cross-crate-mismatch.min.stderr

@@ -1,15 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/const-argument-cross-crate-mismatch.rs:9:67
-   |
-LL |     let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
-   |                                                                   ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
-
-error[E0308]: mismatched types
-  --> $DIR/const-argument-cross-crate-mismatch.rs:11:65
-   |
-LL |     let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
-   |                                                                 ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0308`.

src/test/ui/const-generics/const-argument-cross-crate-mismatch.rs

@@ -1,7 +1,4 @@
 // aux-build:const_generic_lib.rs
-// revisions: full min
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 extern crate const_generic_lib;
 

src/test/ui/const-generics/const-argument-cross-crate-mismatch.stderr

@@ -1,11 +1,11 @@
 error[E0308]: mismatched types
-  --> $DIR/const-argument-cross-crate-mismatch.rs:9:67
+  --> $DIR/const-argument-cross-crate-mismatch.rs:6:67
    |
 LL |     let _ = const_generic_lib::function(const_generic_lib::Struct([0u8, 1u8]));
    |                                                                   ^^^^^^^^^^ expected an array with a fixed size of 3 elements, found one with 2 elements
 
 error[E0308]: mismatched types
-  --> $DIR/const-argument-cross-crate-mismatch.rs:11:65
+  --> $DIR/const-argument-cross-crate-mismatch.rs:8:65
    |
 LL |     let _: const_generic_lib::Alias = const_generic_lib::Struct([0u8, 1u8, 2u8]);
    |                                                                 ^^^^^^^^^^^^^^^ expected an array with a fixed size of 2 elements, found one with 3 elements

src/test/ui/const-generics/const-argument-if-length.full.stderr

@@ -1,24 +1,5 @@
 error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/const-argument-if-length.rs:7:28
+  --> $DIR/const-argument-if-length.rs:15:12
-   |
-LL | pub const fn is_zst<T: ?Sized>() -> usize {
-   |                     - this type parameter needs to be `std::marker::Sized`
-LL |     if std::mem::size_of::<T>() == 0 {
-   |                            ^ doesn't have a size known at compile-time
-   |
-note: required by a bound in `std::mem::size_of`
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-   |
-LL | pub const fn size_of<T>() -> usize {
-   |                      ^ required by this bound in `std::mem::size_of`
-help: consider removing the `?Sized` bound to make the type parameter `Sized`
-   |
-LL - pub const fn is_zst<T: ?Sized>() -> usize {
-LL + pub const fn is_zst<T>() -> usize {
-   | 
-
-error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/const-argument-if-length.rs:16:12
    |
 LL | pub struct AtLeastByte<T: ?Sized> {
    |                        - this type parameter needs to be `std::marker::Sized`
@@ -41,6 +22,14 @@ help: the `Box` type always has a statically known size and allocates its conten
 LL |     value: Box<T>,
    |            ++++ +
 
+error: unconstrained generic constant
+  --> $DIR/const-argument-if-length.rs:17:10
+   |
+LL |     pad: [u8; is_zst::<T>()],
+   |          ^^^^^^^^^^^^^^^^^^^
+   |
+   = help: try adding a `where` bound using this expression: `where [(); is_zst::<T>()]:`
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

src/test/ui/const-generics/const-argument-if-length.min.stderr

@@ -1,14 +1,14 @@
 error: generic parameters may not be used in const operations
-  --> $DIR/const-argument-if-length.rs:18:24
+  --> $DIR/const-argument-if-length.rs:17:24
    |
 LL |     pad: [u8; is_zst::<T>()],
    |                        ^ cannot perform const operation using `T`
    |
    = note: type parameters may not be used in const expressions
-   = help: use `#![feature(const_generics)]` and `#![feature(generic_const_exprs)]` to allow generic const expressions
+   = help: use `#![feature(generic_const_exprs)]` to allow generic const expressions
 
 error[E0277]: the size for values of type `T` cannot be known at compilation time
-  --> $DIR/const-argument-if-length.rs:16:12
+  --> $DIR/const-argument-if-length.rs:15:12
    |
 LL | pub struct AtLeastByte<T: ?Sized> {
    |                        - this type parameter needs to be `std::marker::Sized`

src/test/ui/const-generics/const-argument-if-length.rs

@@ -1,11 +1,10 @@
 // revisions: full min
 
+#![cfg_attr(full, feature(generic_const_exprs))]
 #![cfg_attr(full, allow(incomplete_features))]
-#![cfg_attr(full, feature(const_generics))]
 
 pub const fn is_zst<T: ?Sized>() -> usize {
     if std::mem::size_of::<T>() == 0 {
-        //[full]~^ ERROR the size for values of type `T` cannot be known at compilation time
         1
     } else {
         0
@@ -17,6 +16,7 @@ pub struct AtLeastByte<T: ?Sized> {
     //~^ ERROR the size for values of type `T` cannot be known at compilation time
     pad: [u8; is_zst::<T>()],
     //[min]~^ ERROR generic parameters may not be used in const operations
+    //[full]~^^ ERROR unconstrained generic constant
 }
 
 fn main() {}

src/test/ui/const-generics/const-argument-non-static-lifetime.rs

@@ -2,7 +2,7 @@
 // revisions: full
 // FIXME(#75323) Omitted min revision for now due to ICE.
 
-#![cfg_attr(full, feature(const_generics))]
+#![cfg_attr(full, feature(generic_const_exprs))]
 #![cfg_attr(full, allow(incomplete_features))]
 #![allow(dead_code)]
 

src/test/ui/const-generics/const-expression-parameter.min.stderr

@@ -1,13 +0,0 @@
-error: expressions must be enclosed in braces to be used as const generic arguments
-  --> $DIR/const-expression-parameter.rs:15:20
-   |
-LL |     i32_identity::<1 + 2>();
-   |                    ^^^^^
-   |
-help: enclose the `const` expression in braces
-   |
-LL |     i32_identity::<{ 1 + 2 }>();
-   |                    +       +
-
-error: aborting due to previous error
-

src/test/ui/const-generics/const-fn-with-const-param.rs

@@ -1,9 +1,5 @@
 // Checks that `const fn` with const params can be used.
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 const fn const_u32_identity<const X: u32>() -> u32 {
     X

src/test/ui/const-generics/const-generic-array-wrapper.rs

@@ -1,19 +0,0 @@
-// run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
-
-struct Foo<T, const N: usize>([T; N]);
-
-impl<T, const N: usize> Foo<T, N> {
-    fn foo(&self) -> usize {
-        N
-    }
-}
-
-fn main() {
-    let foo = Foo([0u32; 21]);
-    assert_eq!(foo.0, [0u32; 21]);
-    assert_eq!(foo.foo(), 21);
-}

src/test/ui/const-generics/const-generic-type_name.rs

@@ -1,8 +1,4 @@
 // run-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 #[derive(Debug)]
 struct S<const N: usize>;

src/test/ui/const-generics/const-param-after-const-literal-arg.rs

@@ -1,8 +1,4 @@
 // check-pass
-// revisions: full min
-
-#![cfg_attr(full, feature(const_generics))]
-#![cfg_attr(full, allow(incomplete_features))]
 
 struct Foo<const A: usize, const B: usize>;
 

src/test/ui/const-generics/const-param-before-other-params.full.stderr

@@ -1,8 +1,8 @@
 error: lifetime parameters must be declared prior to const parameters
   --> $DIR/const-param-before-other-params.rs:5:21
    |
-LL | fn bar<const X: (), 'a>(_: &'a ()) {
+LL | fn bar<const X: u8, 'a>(_: &'a ()) {
-   |       --------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const X: ()>`
+   |       --------------^^- help: reorder the parameters: lifetimes, then consts and types: `<'a, const X: u8>`
 
 error: aborting due to previous error
 

src/test/ui/const-generics/const-param-before-other-params.min.stderr

@@ -1,32 +1,14 @@
 error: lifetime parameters must be declared prior to const parameters
   --> $DIR/const-param-before-other-params.rs:5:21
    |
-LL | fn bar<const X: (), 'a>(_: &'a ()) {
+LL | fn bar<const X: u8, 'a>(_: &'a ()) {
-   |       --------------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, const X: ()>`
+   |       --------------^^- help: reorder the parameters: lifetimes, then types, then consts: `<'a, const X: u8>`
 
 error: type parameters must be declared prior to const parameters
-  --> $DIR/const-param-before-other-params.rs:10:21
+  --> $DIR/const-param-before-other-params.rs:9:21
    |
-LL | fn foo<const X: (), T>(_: &T) {}
+LL | fn foo<const X: u8, T>(_: &T) {}
-   |       --------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const X: ()>`
+   |       --------------^- help: reorder the parameters: lifetimes, then types, then consts: `<T, const X: u8>`
 
-error: `()` is forbidden as the type of a const generic parameter
+error: aborting due to 2 previous errors
-  --> $DIR/const-param-before-other-params.rs:5:17
-   |
-LL | fn bar<const X: (), 'a>(_: &'a ()) {
-   |                 ^^
-   |
-   = note: the only supported types are integers, `bool` and `char`
-   = help: more complex types are supported with `#![feature(const_generics)]`
-
-error: `()` is forbidden as the type of a const generic parameter
-  --> $DIR/const-param-before-other-params.rs:10:17
-   |
-LL | fn foo<const X: (), T>(_: &T) {}
-   |                 ^^
-   |
-   = note: the only supported types are integers, `bool` and `char`
-   = help: more complex types are supported with `#![feature(const_generics)]`
-
-error: aborting due to 4 previous errors