wip: trait_sel: skip elaboration of sizedness supertrait

As a performance optimization, skip elaborating the supertraits of
`Sized`, and if a `MetaSized` obligation is being checked, then look for
a `Sized` predicate in the parameter environment. This makes the
`ParamEnv` smaller which should improve compiler performance as it avoids
all the iteration over the larger `ParamEnv`.

Author: davidtwco

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -45,7 +45,9 @@ where
         then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         if let Some(host_clause) = assumption.as_host_effect_clause() {
-            if host_clause.def_id() == goal.predicate.def_id()
+            let goal_did = goal.predicate.def_id();
+            let host_clause_did = host_clause.def_id();
+            if host_clause_did == goal_did
                 && host_clause.constness().satisfies(goal.predicate.constness)
             {
                 if !DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
@@ -55,21 +57,34 @@ where
                     return Err(NoSolution);
                 }
 
-                ecx.probe_trait_candidate(source).enter(|ecx| {
+                return ecx.probe_trait_candidate(source).enter(|ecx| {
                     let assumption_trait_pred = ecx.instantiate_binder_with_infer(host_clause);
                     ecx.eq(
                         goal.param_env,
                         goal.predicate.trait_ref,
                         assumption_trait_pred.trait_ref,
                     )?;
                     then(ecx)
-                })
-            } else {
-                Err(NoSolution)
+                });
+            }
+
+            // PERF(sized-hierarchy): Sizedness supertraits aren't elaborated to improve perf, so
+            // check for a `Sized` subtrait when looking for `MetaSized`. `PointeeSized` bounds
+            // are syntactic sugar for a lack of bounds so don't need this.
+            if ecx.cx().is_lang_item(goal_did, TraitSolverLangItem::MetaSized)
+                && ecx.cx().is_lang_item(host_clause_did, TraitSolverLangItem::Sized)
+                && {
+                    let expected_self_ty = ecx.resolve_vars_if_possible(goal.predicate.self_ty());
+                    let found_self_ty =
+                        ecx.resolve_vars_if_possible(host_clause.self_ty().skip_binder());
+                    expected_self_ty == found_self_ty
+                }
+            {
+                return ecx.probe_trait_candidate(source).enter(then);
             }
-        } else {
-            Err(NoSolution)
         }
+
+        Err(NoSolution)
     }
 
     /// Register additional assumptions for aliases corresponding to `~const` item bounds.

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -132,31 +132,44 @@ where
         then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
     ) -> Result<Candidate<I>, NoSolution> {
         if let Some(trait_clause) = assumption.as_trait_clause() {
-            if trait_clause.def_id() == goal.predicate.def_id()
-                && trait_clause.polarity() == goal.predicate.polarity
-            {
+            let goal_did = goal.predicate.def_id();
+            let trait_clause_did = trait_clause.def_id();
+            if trait_clause_did == goal_did && trait_clause.polarity() == goal.predicate.polarity {
                 if !DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
                     goal.predicate.trait_ref.args,
                     trait_clause.skip_binder().trait_ref.args,
                 ) {
                     return Err(NoSolution);
                 }
 
-                ecx.probe_trait_candidate(source).enter(|ecx| {
+                return ecx.probe_trait_candidate(source).enter(|ecx| {
                     let assumption_trait_pred = ecx.instantiate_binder_with_infer(trait_clause);
                     ecx.eq(
                         goal.param_env,
                         goal.predicate.trait_ref,
                         assumption_trait_pred.trait_ref,
                     )?;
                     then(ecx)
-                })
-            } else {
-                Err(NoSolution)
+                });
+            }
+
+            // PERF(sized-hierarchy): Sizedness supertraits aren't elaborated to improve perf, so
+            // check for a `Sized` subtrait when looking for `MetaSized`. `PointeeSized` bounds
+            // are syntactic sugar for a lack of bounds so don't need this.
+            if ecx.cx().is_lang_item(goal_did, TraitSolverLangItem::MetaSized)
+                && ecx.cx().is_lang_item(trait_clause_did, TraitSolverLangItem::Sized)
+                && {
+                    let expected_self_ty = ecx.resolve_vars_if_possible(goal.predicate.self_ty());
+                    let found_self_ty =
+                        ecx.resolve_vars_if_possible(trait_clause.self_ty().skip_binder());
+                    expected_self_ty == found_self_ty
+                }
+            {
+                return ecx.probe_trait_candidate(source).enter(then);
             }
-        } else {
-            Err(NoSolution)
         }
+
+        Err(NoSolution)
     }
 
     fn consider_auto_trait_candidate(

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -8,6 +8,7 @@ use std::fmt::Debug;
 
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_errors::{Diag, EmissionGuarantee};
+use rustc_hir::LangItem;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
 use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, TyCtxtInferExt};
@@ -582,6 +583,21 @@ fn try_prove_negated_where_clause<'tcx>(
         return false;
     };
 
+    let maybe_meta_sized_self_ty = clause
+        .as_trait_clause()
+        .filter(|c| root_infcx.tcx.is_lang_item(c.def_id(), LangItem::MetaSized))
+        .map(|c| c.self_ty());
+    if let Some(meta_sized_self_ty) = maybe_meta_sized_self_ty
+        && util::sizedness_elab_opt_fast_path_from_paramenv(
+            root_infcx,
+            meta_sized_self_ty,
+            param_env,
+        )
+        .is_some()
+    {
+        return false;
+    }
+
     // N.B. We don't need to use intercrate mode here because we're trying to prove
     // the *existence* of a negative goal, not the non-existence of a positive goal.
     // Without this, we over-eagerly register coherence ambiguity candidates when

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -16,7 +16,7 @@ use rustc_infer::traits::{Obligation, PolyTraitObligation, SelectionError};
 use rustc_middle::ty::fast_reject::DeepRejectCtxt;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt, TypingMode};
 use rustc_middle::{bug, span_bug};
-use rustc_type_ir::{Interner, elaborate};
+use rustc_type_ir::{Binder, Interner, elaborate};
 use tracing::{debug, instrument, trace};
 
 use super::SelectionCandidate::*;
@@ -188,15 +188,29 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             let mut distinct_normalized_bounds = FxHashSet::default();
             let _ = self.for_each_item_bound::<!>(
                 placeholder_trait_predicate.self_ty(),
-                |selcx, bound, idx| {
-                    let Some(bound) = bound.as_trait_clause() else {
+                |selcx, clause, idx| {
+                    let Some(bound) = clause.as_trait_clause() else {
                         return ControlFlow::Continue(());
                     };
                     if bound.polarity() != placeholder_trait_predicate.polarity {
                         return ControlFlow::Continue(());
                     }
 
                     selcx.infcx.probe(|_| {
+                        if selcx
+                            .tcx()
+                            .is_lang_item(placeholder_trait_predicate.def_id(), LangItem::MetaSized)
+                            && util::sizedness_elab_opt_fast_path_from_clauses(
+                                selcx.infcx,
+                                Binder::dummy(placeholder_trait_predicate.self_ty()),
+                                [clause],
+                            )
+                            .is_some()
+                        {
+                            candidates.vec.push(ProjectionCandidate(idx));
+                            return;
+                        }
+
                         // We checked the polarity already
                         match selcx.match_normalize_trait_ref(
                             obligation,
@@ -235,6 +249,17 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ) -> Result<(), SelectionError<'tcx>> {
         debug!(?stack.obligation);
 
+        if self.tcx().is_lang_item(stack.obligation.predicate.def_id(), LangItem::MetaSized)
+            && let Some(bound) = util::sizedness_elab_opt_fast_path_from_paramenv(
+                self.infcx,
+                stack.obligation.self_ty(),
+                stack.obligation.param_env,
+            )
+        {
+            candidates.vec.push(ParamCandidate(bound));
+            return Ok(());
+        }
+
         let bounds = stack
             .obligation
             .param_env

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -18,7 +18,7 @@ use rustc_middle::traits::{BuiltinImplSource, SignatureMismatchData};
 use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt, Upcast};
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::DefId;
-use rustc_type_ir::elaborate;
+use rustc_type_ir::{Binder, elaborate};
 use thin_vec::thin_vec;
 use tracing::{debug, instrument};
 
@@ -189,6 +189,17 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             &mut obligations,
         );
 
+        if tcx.is_lang_item(obligation.predicate.def_id(), LangItem::MetaSized)
+            && util::sizedness_elab_opt_fast_path_from_traitrefs(
+                self.infcx,
+                obligation.predicate.self_ty(),
+                [Binder::dummy(candidate)],
+            )
+            .is_some()
+        {
+            return Ok(obligations);
+        }
+
         obligations.extend(
             self.infcx
                 .at(&obligation.cause, obligation.param_env)

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -31,8 +31,9 @@ use rustc_middle::ty::{
     TypingMode, Upcast,
 };
 use rustc_span::{Symbol, sym};
-use rustc_type_ir::elaborate;
 use rustc_type_ir::solve::SizedTraitKind;
+use rustc_type_ir::{Binder, elaborate};
+use thin_vec::thin_vec;
 use tracing::{debug, instrument, trace};
 
 use self::EvaluationResult::*;
@@ -2641,6 +2642,18 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             HigherRankedType,
             poly_trait_ref,
         );
+
+        if self.tcx().is_lang_item(predicate.def_id(), LangItem::MetaSized)
+            && util::sizedness_elab_opt_fast_path_from_traitrefs(
+                self.infcx,
+                Binder::dummy(predicate.self_ty()),
+                [Binder::dummy(trait_ref)],
+            )
+            .is_some()
+        {
+            return Ok(thin_vec![]);
+        }
+
         self.infcx
             .at(&obligation.cause, obligation.param_env)
             .eq(DefineOpaqueTypes::No, predicate.trait_ref, trait_ref)

compiler/rustc_trait_selection/src/traits/util.rs

@@ -9,6 +9,8 @@ use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
 };
 use rustc_span::Span;
+use rustc_type_ir::lang_items::TraitSolverLangItem;
+use rustc_type_ir::{InferCtxtLike, Interner, Upcast};
 use smallvec::{SmallVec, smallvec};
 use tracing::debug;
 
@@ -504,3 +506,68 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for PlaceholderReplacer<'_, 'tcx> {
         }
     }
 }
+
+/// To improve performance, Sizedness traits are not elaborated and so special-casing is required
+/// in the trait solver to find a `Sized` candidate for a `MetaSized` predicate. This is a helper
+/// function for that special-casing, intended to be used when the obligation to be proven has been
+/// confirmed to be `MetaSized`, and checking whether the `param_env` contains `Sized` for the same
+/// `self_ty` is all that remains to be done.
+// Ideally this would be re-used by the next solver, but there is no `InferCtxtLike` implementor.
+pub(crate) fn sizedness_elab_opt_fast_path_from_paramenv<Infcx, I>(
+    infcx: &Infcx,
+    self_ty: rustc_type_ir::Binder<I, I::Ty>,
+    param_env: I::ParamEnv,
+) -> Option<rustc_type_ir::Binder<I, rustc_type_ir::TraitPredicate<I>>>
+where
+    I: Interner,
+    Infcx: InferCtxtLike<Interner = I>,
+{
+    #[allow(rustc::usage_of_type_ir_inherent)]
+    use rustc_type_ir::inherent::*;
+    sizedness_elab_opt_fast_path_from_clauses(infcx, self_ty, param_env.caller_bounds().iter())
+}
+
+/// Same as `sizedness_elab_opt_fast_path_from_paramenv` but takes an iterator of clauses instead
+/// of a parameter environment.
+pub(crate) fn sizedness_elab_opt_fast_path_from_clauses<Infcx, I, Trs>(
+    infcx: &Infcx,
+    self_ty: rustc_type_ir::Binder<I, I::Ty>,
+    clauses: Trs,
+) -> Option<rustc_type_ir::Binder<I, rustc_type_ir::TraitPredicate<I>>>
+where
+    I: Interner,
+    Infcx: InferCtxtLike<Interner = I>,
+    Trs: IntoIterator<Item = I::Clause>,
+{
+    #[allow(rustc::usage_of_type_ir_inherent)]
+    use rustc_type_ir::inherent::*;
+    sizedness_elab_opt_fast_path_from_traitrefs(
+        infcx,
+        self_ty,
+        clauses
+            .into_iter()
+            .filter_map(|p| p.as_trait_clause())
+            .map(|c| c.map_bound(|c| c.trait_ref)),
+    )
+    .map(|f| f.map_bound(|f| f.upcast(infcx.cx())))
+}
+
+/// Same as `sizedness_elab_opt_fast_path_from_paramenv` but takes an iterator of trait refs instead
+/// of a parameter environment.
+pub(crate) fn sizedness_elab_opt_fast_path_from_traitrefs<Infcx, I, TraitRefs>(
+    infcx: &Infcx,
+    self_ty: rustc_type_ir::Binder<I, I::Ty>,
+    trait_refs: TraitRefs,
+) -> Option<rustc_type_ir::Binder<I, rustc_type_ir::TraitRef<I>>>
+where
+    I: Interner,
+    Infcx: InferCtxtLike<Interner = I>,
+    TraitRefs: IntoIterator<Item = rustc_type_ir::Binder<I, rustc_type_ir::TraitRef<I>>>,
+{
+    trait_refs.into_iter().find(|c| {
+        let expected_self_ty = infcx.resolve_vars_if_possible(self_ty);
+        let found_self_ty = infcx.resolve_vars_if_possible(c.self_ty());
+        expected_self_ty == found_self_ty
+            && infcx.cx().is_lang_item(c.def_id(), TraitSolverLangItem::Sized)
+    })
+}