u wu

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -132,6 +132,12 @@ pub trait SolverDelegateEvalExt: SolverDelegate {
  generate_proof_tree: GenerateProofTree,
  ) -> (Result<(bool, Certainty), NoSolution>, Option<inspect::GoalEvaluation<Self::Interner>>);
 
+ fn root_goal_may_hold_with_depth(
+ &self,
+ root_depth: usize,
+ goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
+ ) -> bool;
+
  // FIXME: This is only exposed because we need to use it in `analyse.rs`
  // which is not yet uplifted. Once that's done, we should remove this.
  fn evaluate_root_goal_raw(
@@ -159,11 +165,25 @@ where
  goal: Goal<I, I::Predicate>,
  generate_proof_tree: GenerateProofTree,
  ) -> (Result<(bool, Certainty), NoSolution>, Option<inspect::GoalEvaluation<I>>) {
- EvalCtxt::enter_root(self, generate_proof_tree, |ecx| {
+ EvalCtxt::enter_root(self, self.cx().recursion_limit(), generate_proof_tree, |ecx| {
  ecx.evaluate_goal(GoalEvaluationKind::Root, GoalSource::Misc, goal)
  })
  }
 
+ fn root_goal_may_hold_with_depth(
+ &self,
+ root_depth: usize,
+ goal: Goal<Self::Interner, <Self::Interner as Interner>::Predicate>,
+ ) -> bool {
+ self.probe(|| {
+ EvalCtxt::enter_root(self, root_depth, GenerateProofTree::No, |ecx| {
+ ecx.evaluate_goal(GoalEvaluationKind::Root, GoalSource::Misc, goal)
+ })
+ .0
+ })
+ .is_ok()
+ }
+
  #[instrument(level = "debug", skip(self))]
  fn evaluate_root_goal_raw(
  &self,
@@ -173,7 +193,7 @@ where
  Result<(NestedNormalizationGoals<I>, bool, Certainty), NoSolution>,
  Option<inspect::GoalEvaluation<I>>,
  ) {
- EvalCtxt::enter_root(self, generate_proof_tree, |ecx| {
+ EvalCtxt::enter_root(self, self.cx().recursion_limit(), generate_proof_tree, |ecx| {
  ecx.evaluate_goal_raw(GoalEvaluationKind::Root, GoalSource::Misc, goal)
  })
  }
@@ -197,10 +217,11 @@ where
  /// over using this manually (such as [`SolverDelegateEvalExt::evaluate_root_goal`]).
  pub(super) fn enter_root<R>(
  delegate: &D,
+ root_depth: usize,
  generate_proof_tree: GenerateProofTree,
  f: impl FnOnce(&mut EvalCtxt<'_, D>) -> R,
  ) -> (R, Option<inspect::GoalEvaluation<I>>) {
- let mut search_graph = SearchGraph::new(delegate.solver_mode());
+ let mut search_graph = SearchGraph::new(delegate.solver_mode(), root_depth);
 
  let mut ecx = EvalCtxt {
  delegate,

compiler/rustc_next_trait_solver/src/solve/search_graph.rs

@@ -40,9 +40,6 @@ where
  }
 
  const DIVIDE_AVAILABLE_DEPTH_ON_OVERFLOW: usize = 4;
- fn recursion_limit(cx: I) -> usize {
- cx.recursion_limit()
- }
 
  fn initial_provisional_result(
  cx: I,

compiler/rustc_trait_selection/src/solve.rs

@@ -6,6 +6,7 @@ pub mod inspect;
 mod normalize;
 mod select;
 
+pub(crate) use delegate::SolverDelegate;
 pub use fulfill::{FulfillmentCtxt, NextSolverError};
 pub(crate) use normalize::deeply_normalize_for_diagnostics;
 pub use normalize::{deeply_normalize, deeply_normalize_with_skipped_universes};

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -19,6 +19,7 @@ use rustc_middle::ty::fast_reject::DeepRejectCtxt;
 use rustc_middle::ty::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
 use rustc_middle::ty::{self, Ty, TyCtxt};
 pub use rustc_next_trait_solver::coherence::*;
+use rustc_next_trait_solver::solve::SolverDelegateEvalExt;
 use rustc_span::symbol::sym;
 use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument, warn};
@@ -28,7 +29,7 @@ use crate::error_reporting::traits::suggest_new_overflow_limit;
 use crate::infer::InferOk;
 use crate::infer::outlives::env::OutlivesEnvironment;
 use crate::solve::inspect::{InspectGoal, ProofTreeInferCtxtExt, ProofTreeVisitor};
-use crate::solve::{deeply_normalize_for_diagnostics, inspect};
+use crate::solve::{deeply_normalize_for_diagnostics, inspect, SolverDelegate};
 use crate::traits::query::evaluate_obligation::InferCtxtExt;
 use crate::traits::select::IntercrateAmbiguityCause;
 use crate::traits::{
@@ -333,6 +334,13 @@ fn impl_intersection_has_impossible_obligation<'a, 'cx, 'tcx>(
  let infcx = selcx.infcx;
 
  if infcx.next_trait_solver() {
+ if !obligations.iter().all(|o| {
+ <&SolverDelegate<'tcx>>::from(infcx)
+ .root_goal_may_hold_with_depth(8, Goal::new(infcx.tcx, o.param_env, o.predicate))
+ }) {
+ return IntersectionHasImpossibleObligations::Yes;
+ }
+
  let ocx = ObligationCtxt::new_with_diagnostics(infcx);
  ocx.register_obligations(obligations.iter().cloned());
  let errors_and_ambiguities = ocx.select_all_or_error();

compiler/rustc_type_ir/src/search_graph/mod.rs

@@ -81,7 +81,6 @@ pub trait Delegate {
  fn inspect_is_noop(inspect: &mut Self::ProofTreeBuilder) -> bool;
 
  const DIVIDE_AVAILABLE_DEPTH_ON_OVERFLOW: usize;
- fn recursion_limit(cx: Self::Cx) -> usize;
 
  fn initial_provisional_result(
  cx: Self::Cx,
@@ -156,7 +155,7 @@ impl AvailableDepth {
  /// the remaining depth of all nested goals to prevent hangs
  /// in case there is exponential blowup.
  fn allowed_depth_for_nested<D: Delegate>(
- cx: D::Cx,
+ root_depth: AvailableDepth,
  stack: &IndexVec<StackDepth, StackEntry<D::Cx>>,
  ) -> Option<AvailableDepth> {
  if let Some(last) = stack.raw.last() {
@@ -170,7 +169,7 @@ impl AvailableDepth {
  AvailableDepth(last.available_depth.0 - 1)
  })
  } else {
- Some(AvailableDepth(D::recursion_limit(cx)))
+ Some(root_depth)
  }
  }
 
@@ -360,6 +359,7 @@ struct ProvisionalCacheEntry<X: Cx> {
 
 pub struct SearchGraph<D: Delegate<Cx = X>, X: Cx = <D as Delegate>::Cx> {
  mode: SolverMode,
+ root_depth: AvailableDepth,
  /// The stack of goals currently being computed.
  ///
  /// An element is *deeper* in the stack if its index is *lower*.
@@ -374,9 +374,10 @@ pub struct SearchGraph<D: Delegate<Cx = X>, X: Cx = <D as Delegate>::Cx> {
 }
 
 impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
- pub fn new(mode: SolverMode) -> SearchGraph<D> {
+ pub fn new(mode: SolverMode, root_depth: usize) -> SearchGraph<D> {
  Self {
  mode,
+ root_depth: AvailableDepth(root_depth),
  stack: Default::default(),
  provisional_cache: Default::default(),
  _marker: PhantomData,
@@ -460,7 +461,8 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
  inspect: &mut D::ProofTreeBuilder,
  mut evaluate_goal: impl FnMut(&mut Self, &mut D::ProofTreeBuilder) -> X::Result,
  ) -> X::Result {
- let Some(available_depth) = AvailableDepth::allowed_depth_for_nested::<D>(cx, &self.stack)
+ let Some(available_depth) =
+ AvailableDepth::allowed_depth_for_nested::<D>(self.root_depth, &self.stack)
  else {
  return self.handle_overflow(cx, input, inspect);
  };