Auto merge of #141542 - compiler-errors:rerun, r=<try>

[perf] Don't use ocx in `evaluate_obligation` in new solver

Also tests how bad it is to rerun in `pred_known_to_hold_modulo_regions` in new solver.

r? `@ghost`

Author: bors

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -221,7 +221,7 @@ fn pred_known_to_hold_modulo_regions<'tcx>(
 
     if result.must_apply_modulo_regions() {
         true
-    } else if result.may_apply() {
+    } else if result.may_apply() && !infcx.next_trait_solver() {
         // Sometimes obligations are ambiguous because the recursive evaluator
         // is not smart enough, so we fall back to fulfillment when we're not certain
         // that an obligation holds or not. Even still, we must make sure that

compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs

@@ -1,11 +1,12 @@
 use rustc_macros::extension;
 use rustc_middle::span_bug;
+use rustc_next_trait_solver::solve::{Certainty, GenerateProofTree, SolverDelegateEvalExt};
+use rustc_span::DUMMY_SP;
 
 use crate::infer::InferCtxt;
 use crate::infer::canonical::OriginalQueryValues;
-use crate::traits::{
-    EvaluationResult, ObligationCtxt, OverflowError, PredicateObligation, SelectionContext,
-};
+use crate::solve::SolverDelegate;
+use crate::traits::{EvaluationResult, OverflowError, PredicateObligation, SelectionContext};
 
 #[extension(pub trait InferCtxtExt<'tcx>)]
 impl<'tcx> InferCtxt<'tcx> {
@@ -69,16 +70,14 @@ impl<'tcx> InferCtxt<'tcx> {
 
         if self.next_trait_solver() {
             self.probe(|snapshot| {
-                let ocx = ObligationCtxt::new(self);
-                ocx.register_obligation(obligation.clone());
-                let mut result = EvaluationResult::EvaluatedToOk;
-                for error in ocx.select_all_or_error() {
-                    if error.is_true_error() {
-                        return Ok(EvaluationResult::EvaluatedToErr);
-                    } else {
-                        result = result.max(EvaluationResult::EvaluatedToAmbig);
-                    }
-                }
+                let mut result = match <&SolverDelegate<'tcx>>::from(self)
+                    .evaluate_root_goal(obligation.as_goal(), GenerateProofTree::No, DUMMY_SP)
+                    .0
+                {
+                    Ok((_, Certainty::Yes)) => EvaluationResult::EvaluatedToOk,
+                    Ok((_, Certainty::Maybe(_))) => EvaluationResult::EvaluatedToAmbig,
+                    Err(_) => EvaluationResult::EvaluatedToErr,
+                };
                 if self.opaque_types_added_in_snapshot(snapshot) {
                     result = result.max(EvaluationResult::EvaluatedToOkModuloOpaqueTypes);
                 } else if self.region_constraints_added_in_snapshot(snapshot) {