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,28 @@ 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)
+            {
+                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,38 @@ 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)
+            {
+                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;
     };
 
+    // PERF(sized-hierarchy): Sizedness supertraits aren't elaborated to improve perf, so
+    // check for a `Sized` subtrait when looking for `MetaSized` (even for this negated clause).
+    if clause
+        .as_trait_clause()
+        .map(|c| root_infcx.tcx.is_lang_item(c.def_id(), LangItem::MetaSized))
+        .unwrap_or(false)
+        && param_env
+            .caller_bounds()
+            .iter()
+            .filter_map(|p| p.as_trait_clause())
+            .any(|c| root_infcx.tcx.is_lang_item(c.def_id(), LangItem::Sized))
+    {
+        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

@@ -197,6 +197,22 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
 
                     selcx.infcx.probe(|_| {
+                        // 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 selcx
+                            .tcx()
+                            .is_lang_item(placeholder_trait_predicate.def_id(), LangItem::MetaSized)
+                            && selcx.tcx().is_lang_item(
+                                bound.map_bound(|pred| pred.trait_ref).def_id(),
+                                LangItem::Sized,
+                            )
+                        {
+                            candidates.vec.push(ProjectionCandidate(idx));
+                            return;
+                        }
+
                         // We checked the polarity already
                         match selcx.match_normalize_trait_ref(
                             obligation,
@@ -235,6 +251,22 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ) -> Result<(), SelectionError<'tcx>> {
         debug!(?stack.obligation);
 
+        // 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 self.tcx().is_lang_item(stack.obligation.predicate.def_id(), LangItem::MetaSized)
+            && let Some(bound) = stack
+                .obligation
+                .param_env
+                .caller_bounds()
+                .iter()
+                .filter_map(|p| p.as_trait_clause())
+                .find(|c| self.tcx().is_lang_item(c.def_id(), LangItem::Sized))
+        {
+            candidates.vec.push(ParamCandidate(bound));
+            return Ok(());
+        }
+
         let bounds = stack
             .obligation
             .param_env

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

@@ -189,6 +189,15 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             &mut obligations,
         );
 
+        // 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 tcx.is_lang_item(obligation.predicate.def_id(), LangItem::MetaSized)
+            && tcx.is_lang_item(candidate.def_id, LangItem::Sized)
+        {
+            return Ok(obligations);
+        }
+
         obligations.extend(
             self.infcx
                 .at(&obligation.cause, obligation.param_env)

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

@@ -33,6 +33,7 @@ use rustc_middle::ty::{
 use rustc_span::{Symbol, sym};
 use rustc_type_ir::elaborate;
 use rustc_type_ir::solve::SizedTraitKind;
+use thin_vec::thin_vec;
 use tracing::{debug, instrument, trace};
 
 use self::EvaluationResult::*;
@@ -2641,6 +2642,16 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             HigherRankedType,
             poly_trait_ref,
         );
+
+        // 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 self.tcx().is_lang_item(predicate.def_id(), LangItem::MetaSized)
+            && self.tcx().is_lang_item(trait_ref.def_id, LangItem::Sized)
+        {
+            return Ok(thin_vec![]);
+        }
+
         self.infcx
             .at(&obligation.cause, obligation.param_env)
             .eq(DefineOpaqueTypes::No, predicate.trait_ref, trait_ref)

compiler/rustc_type_ir/src/elaborate.rs

@@ -4,6 +4,7 @@ use smallvec::smallvec;
 
 use crate::data_structures::HashSet;
 use crate::inherent::*;
+use crate::lang_items::TraitSolverLangItem;
 use crate::outlives::{Component, push_outlives_components};
 use crate::{self as ty, Interner, Upcast as _};
 
@@ -79,20 +80,57 @@ pub fn elaborate<I: Interner, O: Elaboratable<I>>(
 ) -> Elaborator<I, O> {
     let mut elaborator =
         Elaborator { cx, stack: Vec::new(), visited: HashSet::default(), mode: Filter::All };
-    elaborator.extend_deduped(obligations);
+    elaborator.extend_deduped(None, obligations);
     elaborator
 }
 
 impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
-    fn extend_deduped(&mut self, obligations: impl IntoIterator<Item = O>) {
+    /// Adds `obligations` to the stack. `current_clause` is the clause which was elaborated to
+    /// produce these obligations.
+    fn extend_deduped(
+        &mut self,
+        current_clause: Option<I::Clause>,
+        obligations: impl IntoIterator<Item = O>,
+    ) {
         // Only keep those bounds that we haven't already seen.
         // This is necessary to prevent infinite recursion in some
         // cases. One common case is when people define
         // `trait Sized: Sized { }` rather than `trait Sized { }`.
         self.stack.extend(
-            obligations.into_iter().filter(|o| {
-                self.visited.insert(self.cx.anonymize_bound_vars(o.predicate().kind()))
-            }),
+            obligations
+                .into_iter()
+                .filter(|o| self.visited.insert(self.cx.anonymize_bound_vars(o.predicate().kind())))
+                .filter(|o| {
+                    let Some(current_clause) = current_clause else {
+                        return true;
+                    };
+                    let Some(next_clause) = o.predicate().as_clause() else {
+                        return true;
+                    };
+
+                    let current_did = match current_clause.kind().skip_binder() {
+                        ty::ClauseKind::Trait(data) => data.def_id(),
+                        ty::ClauseKind::HostEffect(data) => data.def_id(),
+                        _ => return true,
+                    };
+                    let next_did = match next_clause.kind().skip_binder() {
+                        ty::ClauseKind::Trait(data) => data.def_id(),
+                        ty::ClauseKind::HostEffect(data) => data.def_id(),
+                        _ => return true,
+                    };
+
+                    // PERF(sized-hierarchy): To avoid iterating over sizedness supertraits in
+                    // parameter environments, as an optimisation, sizedness supertraits aren't
+                    // elaborated, so check if a `Sized` obligation is being elaborated to a
+                    // `MetaSized` obligation and emit it. Candidate assembly and confirmation
+                    // are modified to check for the `Sized` subtrait when a `MetaSized` obligation
+                    // is present.
+                    if self.cx.is_lang_item(current_did, TraitSolverLangItem::Sized) {
+                        !self.cx.is_lang_item(next_did, TraitSolverLangItem::MetaSized)
+                    } else {
+                        true
+                    }
+                }),
         );
     }
 
@@ -132,12 +170,14 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
                 // Get predicates implied by the trait, or only super predicates if we only care about self predicates.
                 match self.mode {
                     Filter::All => self.extend_deduped(
+                        Some(clause),
                         cx.explicit_implied_predicates_of(data.def_id())
                             .iter_identity()
                             .enumerate()
                             .map(map_to_child_clause),
                     ),
                     Filter::OnlySelf => self.extend_deduped(
+                        Some(clause),
                         cx.explicit_super_predicates_of(data.def_id())
                             .iter_identity()
                             .enumerate()
@@ -147,6 +187,7 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
             }
             // `T: ~const Trait` implies `T: ~const Supertrait`.
             ty::ClauseKind::HostEffect(data) => self.extend_deduped(
+                Some(clause),
                 cx.explicit_implied_const_bounds(data.def_id()).iter_identity().map(|trait_ref| {
                     elaboratable.child(
                         trait_ref
@@ -177,6 +218,7 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
                 let mut components = smallvec![];
                 push_outlives_components(cx, ty_max, &mut components);
                 self.extend_deduped(
+                    Some(clause),
                     components
                         .into_iter()
                         .filter_map(|component| elaborate_component_to_clause(cx, component, r_min))

tests/ui/attributes/dump-preds.stderr

@@ -42,7 +42,6 @@ LL |     type Assoc<P: Eq>: std::ops::Deref<Target = ()>
    = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::ops::Deref>, polarity:Positive), bound_vars: [] }
    = note: Binder { value: HostEffectPredicate { trait_ref: <<Self as Trait<T>>::Assoc<P> as std::marker::Sized>, constness: Const }, bound_vars: [] }
    = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::marker::Sized>, polarity:Positive), bound_vars: [] }
-   = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::marker::MetaSized>, polarity:Positive), bound_vars: [] }
 
 error: aborting due to 3 previous errors
 

tests/ui/extern/extern-types-unsized.rs

@@ -27,7 +27,9 @@ fn main() {
 
     assert_sized::<Bar<A>>();
     //~^ ERROR the size for values of type
+    //~| ERROR the size for values of type
 
     assert_sized::<Bar<Bar<A>>>();
     //~^ ERROR the size for values of type
+    //~| ERROR the size for values of type
 }

tests/ui/extern/extern-types-unsized.stderr

@@ -59,8 +59,21 @@ help: consider relaxing the implicit `Sized` restriction
 LL | fn assert_sized<T: ?Sized>() {}
    |                  ++++++++
 
+error[E0277]: the size for values of type `A` cannot be known
+  --> $DIR/extern-types-unsized.rs:28:20
+   |
+LL |     assert_sized::<Bar<A>>();
+   |                    ^^^^^^ doesn't have a known size
+   |
+   = help: the trait `MetaSized` is not implemented for `A`
+note: required by a bound in `Bar`
+  --> $DIR/extern-types-unsized.rs:14:12
+   |
+LL | struct Bar<T: ?Sized> {
+   |            ^ required by this bound in `Bar`
+
 error[E0277]: the size for values of type `A` cannot be known at compilation time
-  --> $DIR/extern-types-unsized.rs:31:20
+  --> $DIR/extern-types-unsized.rs:32:20
    |
 LL |     assert_sized::<Bar<Bar<A>>>();
    |                    ^^^^^^^^^^^ doesn't have a size known at compile-time
@@ -81,6 +94,19 @@ help: consider relaxing the implicit `Sized` restriction
 LL | fn assert_sized<T: ?Sized>() {}
    |                  ++++++++
 
-error: aborting due to 4 previous errors
+error[E0277]: the size for values of type `A` cannot be known
+  --> $DIR/extern-types-unsized.rs:32:20
+   |
+LL |     assert_sized::<Bar<Bar<A>>>();
+   |                    ^^^^^^^^^^^ doesn't have a known size
+   |
+   = help: the trait `MetaSized` is not implemented for `A`
+note: required by a bound in `Bar`
+  --> $DIR/extern-types-unsized.rs:14:12
+   |
+LL | struct Bar<T: ?Sized> {
+   |            ^ required by this bound in `Bar`
+
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

tests/ui/nll/issue-50716.rs

@@ -5,7 +5,7 @@ trait A {
     type X: ?Sized;
 }
 
-fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>) //~ ERROR mismatched types
+fn foo<'a, T: 'static>(s: Box<<&'a T as A>::X>)
 where
     for<'b> &'b T: A,
     <&'static T as A>::X: Sized