perf experiment: revert changes to unelaborated fast path

Author: davidtwco

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

@@ -217,8 +217,12 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
 
                     selcx.infcx.probe(|_| {
-                        let bound =
-                            util::unelaborated_sizedness_candidate(selcx.infcx, obligation, bound);
+                        if util::unelaborated_sizedness_candidate(selcx.infcx, obligation, bound)
+                            .is_some()
+                        {
+                            candidates.vec.push(ProjectionCandidate(idx));
+                            return;
+                        }
 
                         // We checked the polarity already
                         match selcx.match_normalize_trait_ref(
@@ -258,26 +262,32 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ) -> Result<(), SelectionError<'tcx>> {
         debug!(?stack.obligation);
 
+        if let Some(bound) = stack
+            .obligation
+            .param_env
+            .caller_bounds()
+            .iter()
+            .filter_map(|p| p.as_trait_clause())
+            .find_map(|p| util::unelaborated_sizedness_candidate(self.infcx, stack.obligation, p))
+        {
+            candidates.vec.push(ParamCandidate(bound));
+            return Ok(());
+        }
+
         let bounds = stack
             .obligation
             .param_env
             .caller_bounds()
             .iter()
             .filter_map(|p| p.as_trait_clause())
-            // Micro-optimization: filter out predicates with different polarities.
+            // Micro-optimization: filter out predicates relating to different traits.
+            .filter(|p| p.def_id() == stack.obligation.predicate.def_id())
             .filter(|p| p.polarity() == stack.obligation.predicate.polarity());
 
         let drcx = DeepRejectCtxt::relate_rigid_rigid(self.tcx());
         let obligation_args = stack.obligation.predicate.skip_binder().trait_ref.args;
         // Keep only those bounds which may apply, and propagate overflow if it occurs.
         for bound in bounds {
-            let bound = util::unelaborated_sizedness_candidate(self.infcx, stack.obligation, bound);
-
-            // Micro-optimization: filter out predicates relating to different traits.
-            if bound.def_id() != stack.obligation.predicate.def_id() {
-                continue;
-            }
-
             let bound_trait_ref = bound.map_bound(|t| t.trait_ref);
             if !drcx.args_may_unify(obligation_args, bound_trait_ref.skip_binder().args) {
                 continue;

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

@@ -168,8 +168,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let candidate_predicate = candidate_predicate
             .as_trait_clause()
             .expect("projection candidate is not a trait predicate");
-        let candidate_predicate =
-            util::unelaborated_sizedness_candidate(self.infcx, obligation, candidate_predicate);
+        if util::unelaborated_sizedness_candidate(self.infcx, obligation, candidate_predicate)
+            .is_some()
+        {
+            return Ok(PredicateObligations::new());
+        }
 
         let candidate = candidate_predicate.map_bound(|t| t.trait_ref);
 
@@ -228,13 +231,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     ) -> PredicateObligations<'tcx> {
         debug!(?obligation, ?param, "confirm_param_candidate");
 
-        let param = util::unelaborated_sizedness_candidate(
-            self.infcx,
-            obligation,
-            param.upcast(self.infcx.tcx),
-        )
-        .map_bound(|p| p.trait_ref);
-
         // During evaluation, we already checked that this
         // where-clause trait-ref could be unified with the obligation
         // trait-ref. Repeat that unification now without any

compiler/rustc_trait_selection/src/traits/util.rs

@@ -539,12 +539,12 @@ pub(crate) fn unelaborated_sizedness_candidate<'tcx>(
     infcx: &InferCtxt<'tcx>,
     obligation: &PolyTraitObligation<'tcx>,
     candidate: PolyTraitPredicate<'tcx>,
-) -> PolyTraitPredicate<'tcx> {
+) -> Option<PolyTraitPredicate<'tcx>> {
     use crate::infer::InferCtxtExt;
     if !infcx.tcx.is_lang_item(obligation.predicate.def_id(), LangItem::MetaSized)
         || !infcx.tcx.is_lang_item(candidate.def_id(), LangItem::Sized)
     {
-        return candidate;
+        return None;
     }
 
     let drcx = DeepRejectCtxt::relate_rigid_rigid(infcx.tcx);
@@ -564,15 +564,15 @@ pub(crate) fn unelaborated_sizedness_candidate<'tcx>(
         };
 
     if matches {
-        candidate.map_bound(|c| TraitPredicate {
+        Some(candidate.map_bound(|c| TraitPredicate {
             trait_ref: TraitRef::new_from_args(
                 infcx.tcx,
                 obligation.predicate.def_id(),
                 c.trait_ref.args,
             ),
             polarity: c.polarity,
-        })
+        }))
     } else {
-        candidate
+        None
     }
 }

tests/ui/where-clauses/ignore-err-clauses.rs

@@ -1,7 +1,6 @@
 use std::ops::Add;
 
 fn dbl<T>(x: T) -> <T as Add>::Output
-//~^ ERROR type annotations needed
 where
     T: Copy + Add,
     UUU: Copy,

tests/ui/where-clauses/ignore-err-clauses.stderr

@@ -1,16 +1,9 @@
 error[E0412]: cannot find type `UUU` in this scope
-  --> $DIR/ignore-err-clauses.rs:7:5
+  --> $DIR/ignore-err-clauses.rs:6:5
    |
 LL |     UUU: Copy,
    |     ^^^ not found in this scope
 
-error[E0282]: type annotations needed
-  --> $DIR/ignore-err-clauses.rs:3:14
-   |
-LL | fn dbl<T>(x: T) -> <T as Add>::Output
-   |              ^ cannot infer type for type parameter `T`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
-Some errors have detailed explanations: E0282, E0412.
-For more information about an error, try `rustc --explain E0282`.
+For more information about this error, try `rustc --explain E0412`.