Split part of adt_const_params into unsized_const_params

Author: BoxyUwU

compiler/rustc_builtin_macros/src/deriving/bounds.rs

@@ -38,7 +38,7 @@ pub(crate) fn expand_deriving_const_param_ty(
 ) {
     let trait_def = TraitDef {
         span,
-        path: path_std!(marker::ConstParamTy),
+        path: path_std!(marker::ConstParamTy_),
         skip_path_as_bound: false,
         needs_copy_as_bound_if_packed: false,
         additional_bounds: vec![ty::Ty::Path(path_std!(cmp::Eq))],

compiler/rustc_feature/src/unstable.rs

@@ -632,6 +632,9 @@ declare_features! (
     (unstable, unsafe_attributes, "1.80.0", Some(123757)),
     /// Allows unsafe on extern declarations and safety qualifiers over internal items.
     (unstable, unsafe_extern_blocks, "1.80.0", Some(123743)),
+    /// Allows const generic parameters to be defined with types that
+    /// are not `Sized`, e.g. `fn foo<const N: [u8]>() {`.
+    (incomplete, unsized_const_parameters, "CURRENT_RUSTC_VERSION", Some(95174)),
     /// Allows unsized fn parameters.
     (internal, unsized_fn_params, "1.49.0", Some(48055)),
     /// Allows unsized rvalues at arguments and parameters.

compiler/rustc_hir_analysis/messages.ftl

@@ -78,14 +78,14 @@ hir_analysis_const_impl_for_non_const_trait =
     .note = marking a trait with `#[const_trait]` ensures all default method bodies are `const`
     .adding = adding a non-const method body in the future would be a breaking change
 
-hir_analysis_const_param_ty_impl_on_unsized =
-    the trait `ConstParamTy` may not be implemented for this type
-    .label = type is not `Sized`
-
 hir_analysis_const_param_ty_impl_on_non_adt =
     the trait `ConstParamTy` may not be implemented for this type
     .label = type is not a structure or enumeration
 
+hir_analysis_const_param_ty_impl_on_unsized =
+    the trait `ConstParamTy` may not be implemented for this type
+    .label = type is not `Sized`
+
 hir_analysis_const_specialize = cannot specialize on const impl with non-const impl
 
 hir_analysis_copy_impl_on_non_adt =

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -934,12 +934,43 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
                         ty,
                         tcx.require_lang_item(LangItem::ConstParamTy, Some(hir_ty.span)),
                     );
-                    wfcx.register_bound(
-                        ObligationCause::new(hir_ty.span, param.def_id, ObligationCauseCode::Misc),
-                        wfcx.param_env,
-                        ty,
-                        tcx.require_lang_item(LangItem::Sized, Some(hir_ty.span)),
-                    );
+                    if !tcx.features().unsized_const_parameters {
+                        let cause = ObligationCause::new(
+                            hir_ty.span,
+                            param.def_id,
+                            ObligationCauseCode::Misc,
+                        );
+
+                        wfcx.register_bound(
+                            cause.clone(),
+                            wfcx.param_env,
+                            ty,
+                            tcx.require_lang_item(LangItem::Sized, Some(hir_ty.span)),
+                        );
+
+                        // FIXME(unsized_const_parameters): Just remove the `ConstParamTy` impl on references
+                        // and make `const N: [u8]` work then we can get rid of this.
+                        if let Ok(ty) = wfcx.structurally_normalize(&cause, wfcx.param_env, ty)
+                            && let ty::Ref(..) = ty.kind()
+                        {
+                            let mut diag = tcx.dcx().struct_span_err(
+                                hir_ty.span,
+                                "references are forbidden as the type of const generic parameters",
+                            );
+                            diag.note("only types that implement `ConstParamTy` are permitted");
+
+                            tcx.disabled_nightly_features(
+                                &mut diag,
+                                Some(param.hir_id),
+                                [(
+                                    " references to implement the `ConstParamTy` trait".into(),
+                                    sym::unsized_const_parameters,
+                                )],
+                            );
+
+                            return Err(diag.emit());
+                        }
+                    }
                     Ok(())
                 })
             } else {
@@ -962,6 +993,8 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
                 diag.note("the only supported types are integers, `bool` and `char`");
 
                 let cause = ObligationCause::misc(hir_ty.span, param.def_id);
+                let adt_const_params_feature_string =
+                    " more complex and user defined types".to_string();
                 let may_suggest_feature = match type_allowed_to_implement_const_param_ty(
                     tcx,
                     tcx.param_env(param.def_id),
@@ -971,9 +1004,17 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
                     // Can never implement `ConstParamTy`, don't suggest anything.
                     Err(
                         ConstParamTyImplementationError::NotAnAdtOrBuiltinAllowed
-                        | ConstParamTyImplementationError::InvalidInnerTyOfBuiltinTy(..)
-                        | ConstParamTyImplementationError::TypeNotSized,
-                    ) => false,
+                        | ConstParamTyImplementationError::InvalidInnerTyOfBuiltinTy(..),
+                    ) => None,
+                    Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired) => {
+                        Some(vec![
+                            (adt_const_params_feature_string, sym::adt_const_params),
+                            (
+                                " references to implement the `ConstParamTy` trait".into(),
+                                sym::unsized_const_parameters,
+                            ),
+                        ])
+                    }
                     // May be able to implement `ConstParamTy`. Only emit the feature help
                     // if the type is local, since the user may be able to fix the local type.
                     Err(ConstParamTyImplementationError::InfrigingFields(..)) => {
@@ -993,20 +1034,16 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
                             }
                         }
 
-                        ty_is_local(ty)
+                        ty_is_local(ty).then_some(vec![(
+                            adt_const_params_feature_string,
+                            sym::adt_const_params,
+                        )])
                     }
                     // Implments `ConstParamTy`, suggest adding the feature to enable.
-                    Ok(..) => true,
+                    Ok(..) => Some(vec![(adt_const_params_feature_string, sym::adt_const_params)]),
                 };
-                if may_suggest_feature {
-                    tcx.disabled_nightly_features(
-                        &mut diag,
-                        Some(param.hir_id),
-                        [(
-                            " more complex and user defined types".to_string(),
-                            sym::adt_const_params,
-                        )],
-                    );
+                if let Some(features) = may_suggest_feature {
+                    tcx.disabled_nightly_features(&mut diag, Some(param.hir_id), features);
                 }
 
                 Err(diag.emit())

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -162,7 +162,7 @@ fn visit_implementation_of_const_param_ty(checker: &Checker<'_>) -> Result<(), E
                 span,
             ))
         }
-        Err(ConstParamTyImplementationError::TypeNotSized) => {
+        Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired) => {
             let span = tcx.hir().expect_item(impl_did).expect_impl().self_ty.span;
             Err(tcx.dcx().emit_err(errors::ConstParamTyImplOnUnsized { span }))
         }

compiler/rustc_span/src/symbol.rs

@@ -177,6 +177,7 @@ symbols! {
         CoerceUnsized,
         Command,
         ConstParamTy,
+        ConstParamTy_,
         Context,
         Continue,
         Copy,
@@ -2000,6 +2001,7 @@ symbols! {
         unsafe_no_drop_flag,
         unsafe_pin_internals,
         unsize,
+        unsized_const_parameters,
         unsized_fn_params,
         unsized_locals,
         unsized_tuple_coercion,

compiler/rustc_trait_selection/src/traits/misc.rs

@@ -4,6 +4,7 @@ use crate::regions::InferCtxtRegionExt;
 use crate::traits::{self, FulfillmentError, ObligationCause};
 
 use hir::LangItem;
+use rustc_ast::Mutability;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir as hir;
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
@@ -19,7 +20,7 @@ pub enum CopyImplementationError<'tcx> {
 }
 
 pub enum ConstParamTyImplementationError<'tcx> {
-    TypeNotSized,
+    UnsizedConstParamsFeatureRequired,
     InvalidInnerTyOfBuiltinTy(Vec<(Ty<'tcx>, InfringingFieldsReason<'tcx>)>),
     InfrigingFields(Vec<(&'tcx ty::FieldDef, Ty<'tcx>, InfringingFieldsReason<'tcx>)>),
     NotAnAdtOrBuiltinAllowed,
@@ -91,7 +92,7 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
     self_type: Ty<'tcx>,
     parent_cause: ObligationCause<'tcx>,
 ) -> Result<(), ConstParamTyImplementationError<'tcx>> {
-    {
+    if !tcx.features().unsized_const_parameters {
         // Check for sizedness before recursing into ADT fields so that if someone tries to write:
         // ```rust
         //  #[derive(ConstParamTy)]
@@ -110,7 +111,7 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
         );
 
         if !ocx.select_all_or_error().is_empty() {
-            return Err(ConstParamTyImplementationError::TypeNotSized);
+            return Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired);
         }
     };
 
@@ -121,14 +122,23 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
         // - Have structural equality
         ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => return Ok(()),
 
-        ty::Ref(..) => return Err(ConstParamTyImplementationError::NotAnAdtOrBuiltinAllowed),
+        // Handle types gated under `feature(unsized_const_parameters)`
+        // FIXME(unsized_const_parameters): Make `const N: [u8]` work then forbid references
+        ty::Slice(inner_ty) | ty::Ref(_, inner_ty, Mutability::Not)
+            if tcx.features().unsized_const_parameters =>
+        {
+            vec![inner_ty]
+        }
+        ty::Str if tcx.features().unsized_const_parameters => {
+            vec![Ty::new_slice(tcx, tcx.types.u8)]
+        }
+        ty::Str | ty::Slice(..) | ty::Ref(_, _, Mutability::Not) => {
+            return Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired);
+        }
 
-        // Even if we currently require const params to be `Sized` we may aswell handle them correctly
-        // here anyway.
-        ty::Slice(inner_ty) | ty::Array(inner_ty, _) => vec![inner_ty],
-        // `str` morally acts like a newtype around `[u8]`
-        ty::Str => vec![Ty::new_slice(tcx, tcx.types.u8)],
+        ty::Array(inner_ty, _) => vec![inner_ty],
 
+        // `str` morally acts like a newtype around `[u8]`
         ty::Tuple(inner_tys) => inner_tys.into_iter().collect(),
 
         ty::Adt(adt, args) if adt.is_enum() || adt.is_struct() => {

library/core/src/lib.rs

@@ -248,6 +248,7 @@
 #![feature(transparent_unions)]
 #![feature(try_blocks)]
 #![feature(unboxed_closures)]
+#![feature(unsized_const_parameters)]
 #![feature(unsized_fn_params)]
 #![feature(with_negative_coherence)]
 // tidy-alphabetical-end

library/core/src/marker.rs

@@ -975,13 +975,17 @@ pub trait PointerLike {}
 /// that all fields are also `ConstParamTy`, which implies that recursively, all fields
 /// are `StructuralPartialEq`.
 #[lang = "const_param_ty"]
-#[unstable(feature = "adt_const_params", issue = "95174")]
+#[unstable(feature = "unsized_const_parameters", issue = "95174")]
 #[diagnostic::on_unimplemented(message = "`{Self}` can't be used as a const parameter type")]
 #[allow(multiple_supertrait_upcastable)]
-pub trait ConstParamTy: StructuralPartialEq + Eq {}
+// We name this differently than the derive macro so that the `adt_const_params` can
+// be used independently of `unsized_const_parameters` without requiring a full path
+// to the derive macro every time it is used. This should be renamed on stabilization.
+pub trait ConstParamTy_: StructuralPartialEq + Eq {}
 
 /// Derive macro generating an impl of the trait `ConstParamTy`.
 #[rustc_builtin_macro]
+#[allow_internal_unstable(unsized_const_parameters)]
 #[unstable(feature = "adt_const_params", issue = "95174")]
 pub macro ConstParamTy($item:item) {
     /* compiler built-in */
@@ -990,26 +994,22 @@ pub macro ConstParamTy($item:item) {
 // FIXME(adt_const_params): handle `ty::FnDef`/`ty::Closure`
 marker_impls! {
     #[unstable(feature = "adt_const_params", issue = "95174")]
-    ConstParamTy for
+    ConstParamTy_ for
         usize, u8, u16, u32, u64, u128,
         isize, i8, i16, i32, i64, i128,
         bool,
         char,
         (),
-        {T: ConstParamTy, const N: usize} [T; N],
+        {T: ConstParamTy_, const N: usize} [T; N],
 }
 
-#[unstable(feature = "adt_const_params", issue = "95174")]
-#[rustc_reservation_impl = "types that are not `Sized` are not supported as the type of a const generic parameter"]
-impl<T> ConstParamTy for [T] {}
-
-#[unstable(feature = "adt_const_params", issue = "95174")]
-#[rustc_reservation_impl = "types that are not `Sized` are not supported as the type of a const generic parameter"]
-impl ConstParamTy for str {}
-
-#[unstable(feature = "adt_const_params", issue = "95174")]
-#[rustc_reservation_impl = "references are not supported as the type of a const generic parameter"]
-impl<T: ?Sized> ConstParamTy for &T {}
+marker_impls! {
+    #[unstable(feature = "unsized_const_parameters", issue = "95174")]
+    ConstParamTy_ for
+        str,
+        {T: ConstParamTy_} [T],
+        {T: ConstParamTy_ + ?Sized} &T,
+}
 
 /// A common trait implemented by all function pointers.
 #[unstable(

library/core/src/mem/transmutability.rs

@@ -1,4 +1,4 @@
-use crate::marker::ConstParamTy;
+use crate::marker::ConstParamTy_;
 
 /// Are values of a type transmutable into values of another type?
 ///
@@ -39,7 +39,7 @@ pub struct Assume {
 }
 
 #[unstable(feature = "transmutability", issue = "99571")]
-impl ConstParamTy for Assume {}
+impl ConstParamTy_ for Assume {}
 
 impl Assume {
     /// Do not assume that *you* have ensured any safety properties are met.

library/core/src/tuple.rs

@@ -1,7 +1,7 @@
 // See core/src/primitive_docs.rs for documentation.
 
 use crate::cmp::Ordering::{self, *};
-use crate::marker::ConstParamTy;
+use crate::marker::ConstParamTy_;
 use crate::marker::StructuralPartialEq;
 
 // Recursive macro for implementing n-ary tuple functions and operations
@@ -50,7 +50,7 @@ macro_rules! tuple_impls {
         maybe_tuple_doc! {
             $($T)+ @
             #[unstable(feature = "structural_match", issue = "31434")]
-            impl<$($T: ConstParamTy),+> ConstParamTy for ($($T,)+)
+            impl<$($T: ConstParamTy_),+> ConstParamTy_ for ($($T,)+)
             {}
         }
 

tests/crashes/119299.rs

@@ -2,24 +2,24 @@
 #![feature(adt_const_params)]
 #![allow(incomplete_features)]
 
-use std::marker::ConstParamTy;
+use std::marker::ConstParamTy_;
 
 #[derive(Eq, PartialEq)]
 struct ConstStrU(*const u8, usize);
 
-impl ConstParamTy for &'static ConstStrU {}
+impl ConstParamTy_ for &'static ConstStrU {}
 
 impl ConstStrU {
-  const fn from_bytes(bytes: &'static [u8]) -> Self {
-    Self(bytes.as_ptr(), bytes.len())
-  }
+    const fn from_bytes(bytes: &'static [u8]) -> Self {
+        Self(bytes.as_ptr(), bytes.len())
+    }
 }
 
 const fn chars_s<const S: &'static ConstStrU>() -> [char; 3] {
-  ['a','b','c']
+    ['a', 'b', 'c']
 }
 
 fn main() {
-  const A: &'static ConstStrU = &ConstStrU::from_bytes(b"abc");
-  chars_s::<A>();
+    const A: &'static ConstStrU = &ConstStrU::from_bytes(b"abc");
+    chars_s::<A>();
 }

tests/mir-opt/issue_99325.rs

@@ -1,7 +1,7 @@
 // skip-filecheck
 // EMIT_MIR_FOR_EACH_BIT_WIDTH
 
-#![feature(adt_const_params)]
+#![feature(adt_const_params, unsized_const_parameters)]
 #![allow(incomplete_features)]
 
 pub fn function_with_bytes<const BYTES: &'static [u8; 4]>() -> &'static [u8] {

tests/ui/coherence/negative-coherence/regions-in-canonical.rs

@@ -1,13 +1,12 @@
 //@ check-pass
 
-#![feature(adt_const_params)]
-//~^ WARN the feature `adt_const_params` is incomplete
+#![feature(adt_const_params, unsized_const_parameters)]
+//~^ WARN the feature `unsized_const_parameters` is incomplete
 #![feature(with_negative_coherence, negative_impls)]
 
 pub trait A<const K: &'static str> {}
 pub trait C {}
 
-
 struct W<T>(T);
 
 // Negative coherence: