trait_sel: add sizedness traits to fast path

There's an existing fast path for the `type_op_prove_predicate` predicate
which can be extended to support the new sizedness traits and host effect
predicates, avoiding lots of machinery.

Author: davidtwco

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -23,7 +23,8 @@ use rustc_lint::builtin::SELF_CONSTRUCTOR_FROM_OUTER_ITEM;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{
     self, AdtKind, CanonicalUserType, GenericArgKind, GenericArgsRef, GenericParamDefKind,
-    IsIdentity, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitableExt, UserArgs, UserSelfTy,
+    IsIdentity, SizedTraitKind, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitableExt,
+    UserArgs, UserSelfTy,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint;
@@ -439,7 +440,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 || {},
             );
             // Sized types have static alignment, and so do slices.
-            if tail.is_trivially_sized(self.tcx) || matches!(tail.kind(), ty::Slice(..)) {
+            if tail.has_trivial_sizedness(self.tcx, SizedTraitKind::Sized)
+                || matches!(tail.kind(), ty::Slice(..))
+            {
                 // Nothing else is required here.
             } else {
                 // We can't be sure, let's required full `Sized`.

compiler/rustc_middle/src/ty/sty.rs

@@ -16,6 +16,7 @@ use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, extension};
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 use rustc_type_ir::TyKind::*;
+use rustc_type_ir::solve::SizedTraitKind;
 use rustc_type_ir::{self as ir, BoundVar, CollectAndApply, DynKind, TypeVisitableExt, elaborate};
 use tracing::instrument;
 use ty::util::{AsyncDropGlueMorphology, IntTypeExt};
@@ -1783,7 +1784,7 @@ impl<'tcx> Ty<'tcx> {
         let Some(pointee_ty) = self.builtin_deref(true) else {
             bug!("Type {self:?} is not a pointer or reference type")
         };
-        if pointee_ty.is_trivially_sized(tcx) {
+        if pointee_ty.has_trivial_sizedness(tcx, SizedTraitKind::Sized) {
             tcx.types.unit
         } else {
             match pointee_ty.ptr_metadata_ty_or_tail(tcx, |x| x) {
@@ -1886,17 +1887,16 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
-    /// Fast path helper for testing if a type is `Sized`.
+    /// Fast path helper for testing if a type is `Sized`, `MetaSized` or `PointeeSized`.
     ///
-    /// Returning true means the type is known to be sized. Returning
-    /// `false` means nothing -- could be sized, might not be.
+    /// Returning true means the type is known to implement the sizedness trait. Returning `false`
+    /// means nothing -- could be sized, might not be.
     ///
-    /// Note that we could never rely on the fact that a type such as `[_]` is
-    /// trivially `!Sized` because we could be in a type environment with a
-    /// bound such as `[_]: Copy`. A function with such a bound obviously never
-    /// can be called, but that doesn't mean it shouldn't typecheck. This is why
-    /// this method doesn't return `Option<bool>`.
-    pub fn is_trivially_sized(self, tcx: TyCtxt<'tcx>) -> bool {
+    /// Note that we could never rely on the fact that a type such as `[_]` is trivially `!Sized`
+    /// because we could be in a type environment with a bound such as `[_]: Copy`. A function with
+    /// such a bound obviously never can be called, but that doesn't mean it shouldn't typecheck.
+    /// This is why this method doesn't return `Option<bool>`.
+    pub fn has_trivial_sizedness(self, tcx: TyCtxt<'tcx>, sizedness: SizedTraitKind) -> bool {
         match self.kind() {
             ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
             | ty::Uint(_)
@@ -1919,20 +1919,36 @@ impl<'tcx> Ty<'tcx> {
             | ty::Error(_)
             | ty::Dynamic(_, _, ty::DynStar) => true,
 
-            ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false,
+            ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) => match sizedness {
+                SizedTraitKind::Sized => false,
+                SizedTraitKind::MetaSized | SizedTraitKind::PointeeSized => true,
+            },
+
+            ty::Foreign(..) => match sizedness {
+                SizedTraitKind::Sized | SizedTraitKind::MetaSized => false,
+                SizedTraitKind::PointeeSized => true,
+            },
 
-            ty::Tuple(tys) => tys.last().is_none_or(|ty| ty.is_trivially_sized(tcx)),
+            ty::Tuple(tys) => tys.last().is_none_or(|ty| ty.has_trivial_sizedness(tcx, sizedness)),
 
-            ty::Adt(def, args) => def
-                .sized_constraint(tcx)
-                .is_none_or(|ty| ty.instantiate(tcx, args).is_trivially_sized(tcx)),
+            ty::Adt(def, args) => {
+                let constraint = match sizedness {
+                    SizedTraitKind::Sized => def.sized_constraint(tcx),
+                    SizedTraitKind::MetaSized => def.meta_sized_constraint(tcx),
+                    SizedTraitKind::PointeeSized => def.pointee_sized_constraint(tcx),
+                };
+
+                constraint.is_none_or(|ty| {
+                    ty.instantiate(tcx, args).has_trivial_sizedness(tcx, sizedness)
+                })
+            }
 
             ty::Alias(..) | ty::Param(_) | ty::Placeholder(..) | ty::Bound(..) => false,
 
             ty::Infer(ty::TyVar(_)) => false,
 
             ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
-                bug!("`is_trivially_sized` applied to unexpected type: {:?}", self)
+                bug!("`has_trivial_sizedness` applied to unexpected type: {:?}", self)
             }
         }
     }

compiler/rustc_middle/src/ty/util.rs

@@ -16,6 +16,7 @@ use rustc_index::bit_set::GrowableBitSet;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, extension};
 use rustc_session::Limit;
 use rustc_span::sym;
+use rustc_type_ir::solve::SizedTraitKind;
 use smallvec::{SmallVec, smallvec};
 use tracing::{debug, instrument};
 
@@ -1189,7 +1190,8 @@ impl<'tcx> Ty<'tcx> {
     /// strange rules like `<T as Foo<'static>>::Bar: Sized` that
     /// actually carry lifetime requirements.
     pub fn is_sized(self, tcx: TyCtxt<'tcx>, typing_env: ty::TypingEnv<'tcx>) -> bool {
-        self.is_trivially_sized(tcx) || tcx.is_sized_raw(typing_env.as_query_input(self))
+        self.has_trivial_sizedness(tcx, SizedTraitKind::Sized)
+            || tcx.is_sized_raw(typing_env.as_query_input(self))
     }
 
     /// Checks whether values of this type `T` implement the `Freeze`

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

@@ -196,7 +196,8 @@ where
 /// 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.
+// NOTE: Keep this in sync with `evaluate_host_effect_for_sizedness_goal` in the old solver and
+// `ProvePredicate::try_fast_path`
 #[instrument(level = "trace", skip(cx), ret)]
 pub(in crate::solve) fn const_conditions_for_sizedness<I: Interner>(
     cx: I,

compiler/rustc_trait_selection/src/traits/effects.rs

@@ -253,7 +253,8 @@ fn evaluate_host_effect_from_builtin_impls<'tcx>(
     }
 }
 
-// NOTE: Keep this in sync with `const_conditions_for_sizedness` in the new solver.
+// NOTE: Keep this in sync with `const_conditions_for_sizedness` in the new solver and
+// `ProvePredicate::try_fast_path`
 fn evaluate_host_effect_for_sizedness_goal<'tcx>(
     selcx: &mut SelectionContext<'_, 'tcx>,
     obligation: &HostEffectObligation<'tcx>,

compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs

@@ -3,8 +3,9 @@ use rustc_infer::traits::Obligation;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::traits::query::NoSolution;
 pub use rustc_middle::traits::query::type_op::ProvePredicate;
-use rustc_middle::ty::{self, ParamEnvAnd, TyCtxt};
+use rustc_middle::ty::{self, ParamEnvAnd, SizedTraitKind, TyCtxt};
 use rustc_span::Span;
+use rustc_type_ir::TypeVisitableExt;
 
 use crate::infer::canonical::{CanonicalQueryInput, CanonicalQueryResponse};
 use crate::traits::ObligationCtxt;
@@ -16,16 +17,59 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ProvePredicate<'tcx> {
         tcx: TyCtxt<'tcx>,
         key: &ParamEnvAnd<'tcx, Self>,
     ) -> Option<Self::QueryResponse> {
-        // Proving Sized, very often on "obviously sized" types like
-        // `&T`, accounts for about 60% percentage of the predicates
-        // we have to prove. No need to canonicalize and all that for
-        // such cases.
+        // Proving `Sized`/`MetaSized`/`PointeeSized`, very often on "obviously sized" types like
+        // `&T`, accounts for about 60% percentage of the predicates we have to prove. No need to
+        // canonicalize and all that for such cases.
         if let ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_ref)) =
             key.value.predicate.kind().skip_binder()
-            && tcx.is_lang_item(trait_ref.def_id(), LangItem::Sized)
-            && trait_ref.self_ty().is_trivially_sized(tcx)
         {
-            return Some(());
+            let sizedness = if tcx.is_lang_item(trait_ref.def_id(), LangItem::Sized) {
+                Some(SizedTraitKind::Sized)
+            } else if tcx.is_lang_item(trait_ref.def_id(), LangItem::MetaSized) {
+                Some(SizedTraitKind::MetaSized)
+            } else if tcx.is_lang_item(trait_ref.def_id(), LangItem::PointeeSized) {
+                Some(SizedTraitKind::PointeeSized)
+            } else {
+                None
+            };
+
+            if let Some(sizedness) = sizedness
+                && trait_ref.self_ty().has_trivial_sizedness(tcx, sizedness)
+            {
+                return Some(());
+            }
+
+            if matches!(sizedness, Some(SizedTraitKind::MetaSized)) {
+                let has_sized_in_param_env = key
+                    .param_env
+                    .caller_bounds()
+                    .iter()
+                    .rev() // sizedness predicates are normally at the end for diagnostics reasons
+                    .filter_map(|p| p.as_trait_clause())
+                    .any(|c| {
+                        trait_ref.self_ty() == c.skip_binder().self_ty()
+                            && tcx.is_lang_item(c.def_id(), LangItem::Sized)
+                    });
+                if has_sized_in_param_env {
+                    return Some(());
+                }
+            }
+        }
+
+        // Likewise, determining if a sizedness trait is implemented const-ly is a trivial
+        // determination that can happen in the fast path.
+        //
+        // NOTE: Keep this in sync with `evaluate_host_effect_for_sizedness_goal` in the old solver,
+        // `const_conditions_for_sizedness` in the new solver.
+        if let ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(host_pred)) =
+            key.value.predicate.kind().skip_binder()
+        {
+            let is_sizedness = tcx.is_lang_item(host_pred.def_id(), LangItem::Sized)
+                || tcx.is_lang_item(host_pred.def_id(), LangItem::MetaSized);
+
+            if is_sizedness && !host_pred.self_ty().has_non_const_sizedness() {
+                return Some(());
+            }
         }
 
         if let ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(arg)) =