library/trait_sel: make {Meta,}Sized const

Makes `{Meta,}Sized` into const traits and implements them in the trait
solvers so everything is `Sized` except ADTs with the
`rustc_non_const_sized` attribute.

Author: davidtwco

compiler/rustc_middle/src/ty/adt.rs

@@ -55,6 +55,13 @@ bitflags::bitflags! {
         const IS_UNSAFE_CELL              = 1 << 9;
         /// Indicates whether the type is anonymous.
         const IS_ANONYMOUS                = 1 << 10;
+        /// Indicates whether the type is annotated with `#[rustc_non_const_sized]`.
+        ///
+        /// Necessary to know when to add a type flag since `TyCtxt` isn't available and the
+        /// presence of the attribute cannot be checked.
+        /// FIXME(sized-hierarchy): Consider removing this when scalable vectors are implemented
+        /// and `def.repr.scalable` can be checked.
+        const HAS_NON_CONST_SIZEDNESS      = 1 << 11;
     }
 }
 rustc_data_structures::external_bitflags_debug! { AdtFlags }
@@ -287,6 +294,10 @@ impl AdtDefData {
             flags = flags | AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE;
         }
 
+        if tcx.has_attr(did, sym::rustc_non_const_sized) {
+            flags = flags | AdtFlags::HAS_NON_CONST_SIZEDNESS;
+        }
+
         flags |= match kind {
             AdtKind::Enum => AdtFlags::IS_ENUM,
             AdtKind::Union => AdtFlags::IS_UNION,
@@ -342,6 +353,12 @@ impl<'tcx> AdtDef<'tcx> {
         self.flags().contains(AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE)
     }
 
+    /// Returns `true` if this type only has non-const implementations of sizedness traits.
+    #[inline]
+    pub fn has_non_const_sizedness(self) -> bool {
+        self.flags().contains(AdtFlags::HAS_NON_CONST_SIZEDNESS)
+    }
+
     /// Returns the kind of the ADT.
     #[inline]
     pub fn adt_kind(self) -> AdtKind {

compiler/rustc_middle/src/ty/flags.rs

@@ -183,7 +183,11 @@ impl FlagComputation {
                 }
             }
 
-            &ty::Adt(_, args) => {
+            &ty::Adt(def, args) => {
+                if def.has_non_const_sizedness() {
+                    self.add_flags(TypeFlags::HAS_NON_CONST_SIZEDNESS);
+                }
+
                 self.add_args(args);
             }
 

compiler/rustc_middle/src/ty/return_position_impl_trait_in_trait.rs

@@ -78,8 +78,8 @@ impl<'tcx> TyCtxt<'tcx> {
                                 ty::ExistentialProjection::erase_self_ty(self, projection_pred),
                             ))
                         }
-                        ty::ClauseKind::TypeOutlives(_) => {
-                            // Type outlives bounds don't really turn into anything,
+                        ty::ClauseKind::TypeOutlives(_) | ty::ClauseKind::HostEffect(_) => {
+                            // Type outlives and host effect bounds don't really turn into anything,
                             // since we must use an intersection region for the `dyn*`'s
                             // region anyways.
                             None

compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs

@@ -7,6 +7,7 @@ use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::TraitSolverLangItem;
 use rustc_type_ir::solve::Sizedness;
+use rustc_type_ir::visit::TypeVisitableExt;
 use rustc_type_ir::{self as ty, Interner, Movability, Mutability, Upcast as _, elaborate};
 use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
 use tracing::instrument;
@@ -216,6 +217,35 @@ where
     }
 }
 
+/// Returns the trait refs which need to hold for `self_ty`, with a given `sizedness` trait, to be
+/// `const` - can return `Err(NoSolution)` if the given `self_ty` cannot be const.
+///
+/// This only checks the conditions for constness, not the conditions for the given `sizedness`
+/// trait to be implemented (see the trait goal for that), as these are orthogonal. This means that
+/// the effect predicate can succeed while the trait predicate can fail - this is unintuitive but
+/// allows this function to be much simpler.
+// NOTE: Keep this in sync with `evaluate_host_effect_for_sizedness_goal` in the old solver.
+#[instrument(level = "trace", skip(cx), ret)]
+pub(in crate::solve) fn const_conditions_for_sizedness<I: Interner>(
+    cx: I,
+    self_ty: I::Ty,
+    sizedness: Sizedness,
+) -> Result<Vec<ty::TraitRef<I>>, NoSolution> {
+    // The specific degree of sizedness is orthogonal to whether a type implements any given
+    // sizedness trait const-ly or not.
+
+    if !self_ty.has_non_const_sizedness() && matches!(sizedness, Sizedness::Sized) {
+        let metasized_def_id = cx.require_lang_item(TraitSolverLangItem::MetaSized);
+        let metasized_trait_ref = ty::TraitRef::new(cx, metasized_def_id, [self_ty]);
+        Ok(vec![metasized_trait_ref])
+    } else if !self_ty.has_non_const_sizedness() {
+        // `MetaSized` has no conditionally const supertrait
+        Ok(vec![])
+    } else {
+        Err(NoSolution)
+    }
+}
+
 #[instrument(level = "trace", skip(ecx), ret)]
 pub(in crate::solve) fn instantiate_constituent_tys_for_copy_clone_trait<D, I>(
     ecx: &EvalCtxt<'_, D>,

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -200,11 +200,29 @@ where
     }
 
     fn consider_builtin_sizedness_candidates(
-        _ecx: &mut EvalCtxt<'_, D>,
-        _goal: Goal<I, Self>,
-        _sizedness: Sizedness,
+        ecx: &mut EvalCtxt<'_, D>,
+        goal: Goal<I, Self>,
+        sizedness: Sizedness,
     ) -> Result<Candidate<I>, NoSolution> {
-        unreachable!("Sized/MetaSized/PointeeSized is never const")
+        let cx = ecx.cx();
+
+        let self_ty = goal.predicate.self_ty();
+        let const_conditions =
+            structural_traits::const_conditions_for_sizedness(cx, self_ty, sizedness)?;
+
+        ecx.probe_builtin_trait_candidate(BuiltinImplSource::Trivial).enter(|ecx| {
+            ecx.add_goals(
+                GoalSource::AliasBoundConstCondition,
+                const_conditions.into_iter().map(|trait_ref| {
+                    goal.with(
+                        cx,
+                        ty::Binder::dummy(trait_ref)
+                            .to_host_effect_clause(cx, goal.predicate.constness),
+                    )
+                }),
+            );
+            ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+        })
     }
 
     fn consider_builtin_copy_clone_candidate(

compiler/rustc_trait_selection/src/traits/effects.rs

@@ -5,9 +5,9 @@ use rustc_infer::traits::{
 };
 use rustc_middle::span_bug;
 use rustc_middle::ty::fast_reject::DeepRejectCtxt;
-use rustc_middle::ty::{self, TypingMode};
+use rustc_middle::ty::{self, TypeVisitableExt, TypingMode};
 use rustc_type_ir::elaborate::elaborate;
-use rustc_type_ir::solve::NoSolution;
+use rustc_type_ir::solve::{NoSolution, Sizedness};
 use thin_vec::{ThinVec, thin_vec};
 
 use super::SelectionContext;
@@ -242,10 +242,45 @@ fn evaluate_host_effect_from_builtin_impls<'tcx>(
 ) -> Result<ThinVec<PredicateObligation<'tcx>>, EvaluationFailure> {
     match selcx.tcx().as_lang_item(obligation.predicate.def_id()) {
         Some(LangItem::Destruct) => evaluate_host_effect_for_destruct_goal(selcx, obligation),
+        Some(LangItem::Sized) => {
+            evaluate_host_effect_for_sizedness_goal(selcx, obligation, Sizedness::Sized)
+        }
+        Some(LangItem::MetaSized) => {
+            evaluate_host_effect_for_sizedness_goal(selcx, obligation, Sizedness::MetaSized)
+        }
+        Some(LangItem::PointeeSized) => {
+            evaluate_host_effect_for_sizedness_goal(selcx, obligation, Sizedness::PointeeSized)
+        }
         _ => Err(EvaluationFailure::NoSolution),
     }
 }
 
+// NOTE: Keep this in sync with `const_conditions_for_sizedness` in the new solver.
+fn evaluate_host_effect_for_sizedness_goal<'tcx>(
+    selcx: &mut SelectionContext<'_, 'tcx>,
+    obligation: &HostEffectObligation<'tcx>,
+    sizedness: Sizedness,
+) -> Result<ThinVec<PredicateObligation<'tcx>>, EvaluationFailure> {
+    let tcx = selcx.tcx();
+    let self_ty = obligation.predicate.self_ty();
+
+    if !self_ty.has_non_const_sizedness() && matches!(sizedness, Sizedness::Sized) {
+        let metasized_def_id = tcx.require_lang_item(LangItem::MetaSized, None);
+        let metasized_trait_ref = ty::TraitRef::new(tcx, metasized_def_id, [self_ty]);
+        let metasized_obligation = obligation.with(
+            tcx,
+            ty::Binder::dummy(metasized_trait_ref)
+                .to_host_effect_clause(tcx, obligation.predicate.constness),
+        );
+        Ok(thin_vec![metasized_obligation])
+    } else if !self_ty.has_non_const_sizedness() {
+        // `MetaSized` has no conditionally const supertrait
+        Ok(thin_vec![])
+    } else {
+        Err(EvaluationFailure::NoSolution)
+    }
+}
+
 // NOTE: Keep this in sync with `const_conditions_for_destruct` in the new solver.
 fn evaluate_host_effect_for_destruct_goal<'tcx>(
     selcx: &mut SelectionContext<'_, 'tcx>,

compiler/rustc_type_ir/src/flags.rs

@@ -124,5 +124,8 @@ bitflags::bitflags! {
 
         /// Does this have any binders with bound vars (e.g. that need to be anonymized)?
         const HAS_BINDER_VARS             = 1 << 25;
+
+        /// Does this type only have non-const implementations of sizedness traits?
+        const HAS_NON_CONST_SIZEDNESS    = 1 << 26;
     }
 }

compiler/rustc_type_ir/src/visit.rs

@@ -346,6 +346,11 @@ pub trait TypeVisitableExt<I: Interner>: TypeVisitable<I> {
         self.has_type_flags(TypeFlags::HAS_BOUND_VARS)
     }
 
+    /// Returns `true` if this type only has non-const implementations of sizedness traits.
+    fn has_non_const_sizedness(&self) -> bool {
+        self.has_type_flags(TypeFlags::HAS_NON_CONST_SIZEDNESS)
+    }
+
     /// Indicates whether this value still has parameters/placeholders/inference variables
     /// which could be replaced later, in a way that would change the results of `impl`
     /// specialization.

library/core/src/marker.rs

@@ -151,6 +151,8 @@ unsafe impl<T: Sync + ?Sized + PointeeSized> Send for &T {}
 #[rustc_deny_explicit_impl]
 #[rustc_do_not_implement_via_object]
 #[rustc_coinductive]
+#[cfg_attr(not(bootstrap), const_trait)]
+#[cfg_attr(not(bootstrap), rustc_const_unstable(feature = "sized_hierarchy", issue = "none"))]
 pub trait Sized: MetaSized {
     // Empty.
 }
@@ -167,6 +169,8 @@ pub trait Sized: MetaSized {
 #[cfg_attr(not(bootstrap), rustc_deny_explicit_impl)]
 #[rustc_do_not_implement_via_object]
 #[rustc_coinductive]
+#[cfg_attr(not(bootstrap), const_trait)]
+#[cfg_attr(not(bootstrap), rustc_const_unstable(feature = "sized_hierarchy", issue = "none"))]
 pub trait MetaSized: PointeeSized {
     // Empty
 }

tests/ui/sized-hierarchy/constness.rs

@@ -0,0 +1,38 @@
+//@ compile-flags: -Zunstable-options
+//@ edition: future
+#![allow(internal_features)]
+#![feature(rustc_attrs, const_trait_impl, sized_hierarchy)]
+
+#[rustc_non_const_sized]
+struct NotConstSized;
+
+#[rustc_non_const_sized]
+struct NotConstMetaSized([u8]);
+
+impl NotConstMetaSized {
+    fn new() -> &'static Self { unimplemented!() }
+}
+
+const fn size_of<T: ~const Sized>() { unimplemented!() }
+const fn size_of_val<T: ~const MetaSized>(_t: &T) { unimplemented!() }
+
+fn main() {
+    let _ = const { size_of::<NotConstSized>() };
+//~^ ERROR the trait bound `NotConstSized: const Sized` is not satisfied
+    let _ = size_of::<NotConstSized>();
+
+    let _ = const { size_of::<NotConstMetaSized>() };
+//~^ ERROR the size for values of type `[u8]` cannot be known at compilation time
+    let _ = size_of::<NotConstMetaSized>();
+//~^ ERROR the size for values of type `[u8]` cannot be known at compilation time
+
+    let v = NotConstSized;
+    let _ = const { size_of_val(&v) };
+//~^ ERROR attempt to use a non-constant value in a constant
+    let _ = size_of_val(&v);
+
+    let v = NotConstMetaSized::new();
+    let _ = const { size_of_val(v) };
+//~^ ERROR attempt to use a non-constant value in a constant
+    let _ = size_of_val(v);
+}