Implement trait const stability

Author: fee1-dead

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -709,8 +709,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     if trait_is_const {
                         // Trait calls are always conditionally-const.
                         self.check_op(ops::ConditionallyConstCall { callee, args: fn_args });
-                        // FIXME(const_trait_impl): do a more fine-grained check whether this
-                        // particular trait can be const-stably called.
+                        self.tcx.enforce_trait_const_stability(trait_did, *fn_span);
                     } else {
                         // Not even a const trait.
                         self.check_op(ops::FnCallNonConst {

compiler/rustc_hir_analysis/src/collect.rs

@@ -1612,6 +1612,7 @@ fn check_impl_constness(
 
     let Some(trait_def_id) = hir_trait_ref.trait_def_id() else { return };
     if tcx.is_const_trait(trait_def_id) {
+        tcx.enforce_trait_const_stability(trait_def_id, hir_trait_ref.path.span);
         return;
     }
 

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -741,9 +741,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         };
 
         if let hir::BoundConstness::Always(span) | hir::BoundConstness::Maybe(span) = constness
-            && !self.tcx().is_const_trait(trait_def_id)
         {
-            let (def_span, suggestion, suggestion_pre) =
+            if !self.tcx().is_const_trait(trait_def_id) {
+                let (def_span, suggestion, suggestion_pre) =
                 match (trait_def_id.is_local(), self.tcx().sess.is_nightly_build()) {
                     (true, true) => (
                         None,
@@ -756,14 +756,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     ),
                     (false, _) | (_, false) => (Some(tcx.def_span(trait_def_id)), None, ""),
                 };
-            self.dcx().emit_err(crate::errors::ConstBoundForNonConstTrait {
-                span,
-                modifier: constness.as_str(),
-                def_span,
-                trait_name: self.tcx().def_path_str(trait_def_id),
-                suggestion_pre,
-                suggestion,
-            });
+                self.dcx().emit_err(crate::errors::ConstBoundForNonConstTrait {
+                    span,
+                    modifier: constness.as_str(),
+                    def_span,
+                    trait_name: self.tcx().def_path_str(trait_def_id),
+                    suggestion_pre,
+                    suggestion,
+                });
+            }
+
+            tcx.enforce_trait_const_stability(trait_def_id, span)
         }
 
         match predicate_filter {

compiler/rustc_middle/messages.ftl

@@ -105,6 +105,8 @@ middle_type_length_limit = reached the type-length limit while instantiating `{$
 middle_unknown_layout =
     the type `{$ty}` has an unknown layout
 
+middle_unstable_const_trait = `{$def_path}` is not yet stable as a const trait
+
 middle_values_too_big =
     values of the type `{$ty}` are too big for the target architecture
 middle_written_to_path = the full type name has been written to '{$path}'

compiler/rustc_middle/src/error.rs

@@ -171,3 +171,11 @@ pub struct TypeLengthLimit {
     pub path: PathBuf,
     pub type_length: usize,
 }
+
+#[derive(Diagnostic)]
+#[diag(middle_unstable_const_trait)]
+pub struct UnstableConstTrait {
+    #[primary_span]
+    pub span: Span,
+    pub def_path: String,
+}

compiler/rustc_middle/src/ty/context.rs

@@ -15,6 +15,7 @@ use std::{fmt, iter, mem};
 
 use rustc_abi::{ExternAbi, FieldIdx, Layout, LayoutData, TargetDataLayout, VariantIdx};
 use rustc_ast as ast;
+use rustc_attr_parsing::{ConstStability, StabilityLevel};
 use rustc_data_structures::defer;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashMap;
@@ -3132,6 +3133,35 @@ impl<'tcx> TyCtxt<'tcx> {
             && self.impl_trait_header(def_id).unwrap().constness == hir::Constness::Const
     }
 
+    pub fn enforce_trait_const_stability(self, trait_def_id: DefId, span: Span) {
+        match self.lookup_const_stability(trait_def_id) {
+            Some(ConstStability {
+                level: StabilityLevel::Unstable { implied_by: implied_feature, .. },
+                feature,
+                ..
+            }) => {
+                if span.allows_unstable(feature)
+                    || implied_feature.is_some_and(|f| span.allows_unstable(f))
+                {
+                    return;
+                }
+                let feature_enabled = trait_def_id.is_local()
+                    || self.features().enabled(feature)
+                    || implied_feature.is_some_and(|f| self.features().enabled(f));
+
+                if !feature_enabled {
+                    let mut diag = self.dcx().create_err(crate::error::UnstableConstTrait {
+                        span,
+                        def_path: self.def_path_str(trait_def_id),
+                    });
+                    self.disabled_nightly_features(&mut diag, None, [(String::new(), feature)]);
+                    diag.emit();
+                }
+            }
+            _ => {}
+        }
+    }
+
     pub fn intrinsic(self, def_id: impl IntoQueryParam<DefId> + Copy) -> Option<ty::IntrinsicDef> {
         match self.def_kind(def_id) {
             DefKind::Fn | DefKind::AssocFn => {}

compiler/rustc_passes/src/stability.rs

@@ -593,9 +593,11 @@ impl<'tcx> MissingStabilityAnnotations<'tcx> {
     }
 
     fn check_missing_const_stability(&self, def_id: LocalDefId, span: Span) {
-        let is_const = self.tcx.is_const_fn(def_id.to_def_id());
+        let is_const = self.tcx.is_const_fn(def_id.to_def_id())
+            || (self.tcx.def_kind(def_id.to_def_id()) == DefKind::Trait
+                && self.tcx.is_const_trait(def_id.to_def_id()));
 
-        // Reachable const fn must have a stability attribute.
+        // Reachable const fn/trait must have a stability attribute.
         if is_const
             && self.effective_visibilities.is_reachable(def_id)
             && self.tcx.lookup_const_stability(def_id).is_none()

library/core/src/marker.rs

@@ -960,6 +960,7 @@ marker_impls! {
 /// This should be used for `~const` bounds,
 /// as non-const bounds will always hold for every type.
 #[unstable(feature = "const_destruct", issue = "133214")]
+#[rustc_const_unstable(feature = "const_destruct", issue = "133214")]
 #[lang = "destruct"]
 #[rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg)]
 #[cfg_attr(bootstrap, rustc_deny_explicit_impl(implement_via_object = false))]

library/core/src/ops/arith.rs

@@ -65,6 +65,7 @@
 /// ```
 #[lang = "add"]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_unstable(feature = "const_ops", issue = "90080")]
 #[rustc_on_unimplemented(
     on(all(_Self = "{integer}", Rhs = "{float}"), message = "cannot add a float to an integer",),
     on(all(_Self = "{float}", Rhs = "{integer}"), message = "cannot add an integer to a float",),

library/core/src/ops/deref.rs

@@ -134,6 +134,7 @@
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_diagnostic_item = "Deref"]
 #[cfg_attr(not(bootstrap), const_trait)]
+#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
 pub trait Deref {
     /// The resulting type after dereferencing.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -287,6 +288,7 @@ impl<T: ?Sized> const Deref for &mut T {
 #[doc(alias = "*")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[const_trait]
+#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
 pub trait DerefMut: ~const Deref {
     /// Mutably dereferences the value.
     #[stable(feature = "rust1", since = "1.0.0")]