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/trait_goals.rs

@@ -133,31 +133,52 @@ 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.polarity() != goal.predicate.polarity {
+                return Err(NoSolution);
+            }
+
+            if trait_clause_did == goal_did {
                 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 trait_ref = trait_clause
+                    .self_ty()
+                    .map_bound(|ty| ty::TraitRef::new(ecx.cx(), goal_did, [ty]));
+                return Self::probe_and_match_goal_against_assumption(
+                    ecx,
+                    source,
+                    goal,
+                    trait_ref.upcast(ecx.cx()),
+                    then,
+                );
             }
-        } else {
-            Err(NoSolution)
         }
+
+        Err(NoSolution)
     }
 
     fn consider_auto_trait_candidate(

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

@@ -187,15 +187,26 @@ 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 util::unelaborated_sizedness_candidate(selcx.infcx, obligation, [bound])
+                            .is_some()
+                        {
+                            // As `ProjectionCandidate` takes an index and not a predicate, a
+                            // "corrected" `<Projection>: MetaSized` candidate cannot be created,
+                            // so instead keep the index of the `<Projection>: Sized` predicate and
+                            // correct for this in confirmation.
+                            candidates.vec.push(ProjectionCandidate(idx));
+                            return;
+                        }
+
                         // We checked the polarity already
                         match selcx.match_normalize_trait_ref(
                             obligation,
@@ -234,6 +245,13 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ) -> Result<(), SelectionError<'tcx>> {
         debug!(?stack.obligation);
 
+        if let Some(bound) =
+            util::unelaborated_sizedness_candidate_from_obligation(self.infcx, stack.obligation)
+        {
+            candidates.vec.push(ParamCandidate(bound));
+            return Ok(());
+        }
+
         let bounds = stack
             .obligation
             .param_env

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

@@ -170,6 +170,20 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             .expect("projection candidate is not a trait predicate")
             .map_bound(|t| t.trait_ref);
 
+        // During candidate assembly, if a unelaborated sizedness candidate would have been added,
+        // then the index of the `<Projection>: Sized` predicate that satisfied this
+        // `<Projection>: MetaSized` obligation was used - this means the candidate won't match
+        // the obligation below, so exit early.
+        if util::unelaborated_sizedness_candidate(
+            self.infcx,
+            obligation,
+            [candidate.upcast(self.infcx.tcx)],
+        )
+        .is_some()
+        {
+            return Ok(PredicateObligations::new());
+        }
+
         let candidate = self.infcx.instantiate_binder_with_fresh_vars(
             obligation.cause.span,
             HigherRankedType,

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

@@ -2706,6 +2706,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             HigherRankedType,
             poly_trait_ref,
         );
+
         self.infcx
             .at(&obligation.cause, obligation.param_env)
             .eq(DefineOpaqueTypes::No, predicate.trait_ref, trait_ref)

compiler/rustc_trait_selection/src/traits/util.rs

@@ -4,10 +4,12 @@ use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_hir::LangItem;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::InferCtxt;
+use rustc_infer::traits::PolyTraitObligation;
 pub use rustc_infer::traits::util::*;
 use rustc_middle::bug;
 use rustc_middle::ty::{
-    self, SizedTraitKind, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
+    self, PolyTraitPredicate, SizedTraitKind, Ty, TyCtxt, TypeFoldable, TypeFolder,
+    TypeSuperFoldable, TypeVisitableExt,
 };
 use rustc_span::Span;
 use smallvec::{SmallVec, smallvec};
@@ -531,3 +533,48 @@ pub fn sizedness_fast_path<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tc
 
     false
 }
+
+/// 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` obligation. Returns the
+/// predicate to used in the candidate for such a `obligation`, given `candidates`.
+pub(crate) fn unelaborated_sizedness_candidate<'tcx>(
+    infcx: &InferCtxt<'tcx>,
+    obligation: &PolyTraitObligation<'tcx>,
+    candidates: impl IntoIterator<Item = PolyTraitPredicate<'tcx>>,
+) -> Option<PolyTraitPredicate<'tcx>> {
+    use crate::infer::InferCtxtExt;
+    if !infcx.tcx.is_lang_item(obligation.predicate.def_id(), LangItem::MetaSized) {
+        return None;
+    }
+
+    let has = candidates.into_iter().any(|c| {
+        if !infcx.tcx.is_lang_item(c.def_id(), LangItem::Sized) {
+            return false;
+        }
+
+        let expected_self_ty = obligation.self_ty();
+        let found_self_ty = c.self_ty();
+        obligation.predicate.polarity() == c.polarity()
+            && expected_self_ty.bound_vars() == found_self_ty.bound_vars()
+            && {
+                let expected_self_ty =
+                    infcx.tcx.instantiate_bound_regions_with_erased(expected_self_ty);
+                let found_self_ty = infcx.tcx.instantiate_bound_regions_with_erased(found_self_ty);
+                infcx.can_eq(obligation.param_env, expected_self_ty, found_self_ty)
+            }
+    });
+
+    if has { Some(obligation.predicate) } else { None }
+}
+
+/// See `unelaborated_sizedness_candidate`, but uses `Obligation::param_env` as `candidates`.
+pub(crate) fn unelaborated_sizedness_candidate_from_obligation<'tcx>(
+    infcx: &InferCtxt<'tcx>,
+    obligation: &PolyTraitObligation<'tcx>,
+) -> Option<PolyTraitPredicate<'tcx>> {
+    unelaborated_sizedness_candidate(
+        infcx,
+        obligation,
+        obligation.param_env.caller_bounds().iter().filter_map(|c| c.as_trait_clause()),
+    )
+}

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,55 @@ 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(),
+                        _ => return true,
+                    };
+                    let next_did = match next_clause.kind().skip_binder() {
+                        ty::ClauseKind::Trait(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 +168,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 +185,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 +216,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

@@ -36,7 +36,6 @@ LL |     type Assoc<P: Eq>: std::ops::Deref<Target = ()>
    = note: Binder { value: ProjectionPredicate(AliasTerm { args: [Alias(Projection, AliasTy { args: [Self/#0, T/#1, P/#2], def_id: DefId(..), .. })], def_id: DefId(..), .. }, Term::Ty(())), bound_vars: [] }
    = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::ops::Deref>, polarity:Positive), 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