feature(const_generics) -> feature(const_param_types)

Author: lcnr

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!()