Skip to content

Commit 3ad09f2

Browse files
lcnrlcnr
committed
distinguish recursion limit based overflow for diagnostics
also change the number of allowed fixpoint steps to be fixed instead of using the `log` of the total recursion depth.
1 parent 0250ef2 commit 3ad09f2

24 files changed

+84
-121
lines changed

‎compiler/rustc_infer/src/traits/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -144,7 +144,7 @@ pub enum FulfillmentErrorCode<'tcx> {
144144
Ambiguity {
145145
/// Overflow reported from the new solver `-Znext-solver`, which will
146146
/// be reported as an regular error as opposed to a fatal error.
147-
overflow: bool,
147+
overflow: Option<bool>,
148148
},
149149
}
150150

‎compiler/rustc_infer/src/traits/structural_impls.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -47,8 +47,10 @@ impl<'tcx> fmt::Debug for traits::FulfillmentErrorCode<'tcx> {
4747
ConstEquateError(ref a, ref b) => {
4848
write!(f, "CodeConstEquateError({a:?}, {b:?})")
4949
}
50-
Ambiguity { overflow: false } => write!(f, "Ambiguity"),
51-
Ambiguity { overflow: true } => write!(f, "Overflow"),
50+
Ambiguity { overflow: None } => write!(f, "Ambiguity"),
51+
Ambiguity { overflow: Some(suggest_increasing_limit) } => {
52+
write!(f, "Overflow({suggest_increasing_limit})")
53+
}
5254
Cycle(ref cycle) => write!(f, "Cycle({cycle:?})"),
5355
}
5456
}

‎compiler/rustc_middle/src/traits/solve.rs

Lines changed: 20 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,6 @@ pub enum Certainty {
6060

6161
impl Certainty {
6262
pub const AMBIGUOUS: Certainty = Certainty::Maybe(MaybeCause::Ambiguity);
63-
pub const OVERFLOW: Certainty = Certainty::Maybe(MaybeCause::Overflow);
6463

6564
/// Use this function to merge the certainty of multiple nested subgoals.
6665
///
@@ -79,16 +78,13 @@ impl Certainty {
7978
(Certainty::Yes, Certainty::Yes) => Certainty::Yes,
8079
(Certainty::Yes, Certainty::Maybe(_)) => other,
8180
(Certainty::Maybe(_), Certainty::Yes) => self,
82-
(Certainty::Maybe(MaybeCause::Ambiguity), Certainty::Maybe(MaybeCause::Ambiguity)) => {
83-
Certainty::Maybe(MaybeCause::Ambiguity)
84-
}
85-
(Certainty::Maybe(MaybeCause::Ambiguity), Certainty::Maybe(MaybeCause::Overflow))
86-
| (Certainty::Maybe(MaybeCause::Overflow), Certainty::Maybe(MaybeCause::Ambiguity))
87-
| (Certainty::Maybe(MaybeCause::Overflow), Certainty::Maybe(MaybeCause::Overflow)) => {
88-
Certainty::Maybe(MaybeCause::Overflow)
89-
}
81+
(Certainty::Maybe(a), Certainty::Maybe(b)) => Certainty::Maybe(a.unify_with(b)),
9082
}
9183
}
84+
85+
pub const fn overflow(suggest_increasing_limit: bool) -> Certainty {
86+
Certainty::Maybe(MaybeCause::Overflow { suggest_increasing_limit })
87+
}
9288
}
9389

9490
/// Why we failed to evaluate a goal.
@@ -99,7 +95,21 @@ pub enum MaybeCause {
9995
/// or we hit a case where we just don't bother, e.g. `?x: Trait` goals.
10096
Ambiguity,
10197
/// We gave up due to an overflow, most often by hitting the recursion limit.
102-
Overflow,
98+
Overflow { suggest_increasing_limit: bool },
99+
}
100+
101+
impl MaybeCause {
102+
fn unify_with(self, other: MaybeCause) -> MaybeCause {
103+
match (self, other) {
104+
(MaybeCause::Ambiguity, MaybeCause::Ambiguity) => MaybeCause::Ambiguity,
105+
(MaybeCause::Ambiguity, MaybeCause::Overflow { .. }) => other,
106+
(MaybeCause::Overflow { .. }, MaybeCause::Ambiguity) => self,
107+
(
108+
MaybeCause::Overflow { suggest_increasing_limit: a },
109+
MaybeCause::Overflow { suggest_increasing_limit: b },
110+
) => MaybeCause::Overflow { suggest_increasing_limit: a || b },
111+
}
112+
}
103113
}
104114

105115
#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, HashStable, TypeFoldable, TypeVisitable)]

‎compiler/rustc_trait_selection/src/solve/alias_relate.rs

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -35,11 +35,13 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
3535
let Goal { param_env, predicate: (lhs, rhs, direction) } = goal;
3636

3737
let Some(lhs) = self.try_normalize_term(param_env, lhs)? else {
38-
return self.evaluate_added_goals_and_make_canonical_response(Certainty::OVERFLOW);
38+
return self
39+
.evaluate_added_goals_and_make_canonical_response(Certainty::overflow(true));
3940
};
4041

4142
let Some(rhs) = self.try_normalize_term(param_env, rhs)? else {
42-
return self.evaluate_added_goals_and_make_canonical_response(Certainty::OVERFLOW);
43+
return self
44+
.evaluate_added_goals_and_make_canonical_response(Certainty::overflow(true));
4345
};
4446

4547
let variance = match direction {

‎compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs

Lines changed: 16 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ use rustc_infer::infer::{
77
BoundRegionConversionTime, DefineOpaqueTypes, InferCtxt, InferOk, TyCtxtInferExt,
88
};
99
use rustc_infer::traits::query::NoSolution;
10+
use rustc_infer::traits::solve::MaybeCause;
1011
use rustc_infer::traits::ObligationCause;
1112
use rustc_middle::infer::canonical::CanonicalVarInfos;
1213
use rustc_middle::infer::unify_key::{ConstVariableOrigin, ConstVariableOriginKind};
@@ -29,7 +30,7 @@ use std::ops::ControlFlow;
2930
use crate::traits::vtable::{count_own_vtable_entries, prepare_vtable_segments, VtblSegment};
3031

3132
use super::inspect::ProofTreeBuilder;
32-
use super::{search_graph, GoalEvaluationKind};
33+
use super::{search_graph, GoalEvaluationKind, FIXPOINT_STEP_LIMIT};
3334
use super::{search_graph::SearchGraph, Goal};
3435
use super::{GoalSource, SolverMode};
3536
pub use select::InferCtxtSelectExt;
@@ -157,10 +158,6 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
157158
self.search_graph.solver_mode()
158159
}
159160

160-
pub(super) fn local_overflow_limit(&self) -> usize {
161-
self.search_graph.local_overflow_limit()
162-
}
163-
164161
/// Creates a root evaluation context and search graph. This should only be
165162
/// used from outside of any evaluation, and other methods should be preferred
166163
/// over using this manually (such as [`InferCtxtEvalExt::evaluate_root_goal`]).
@@ -170,7 +167,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
170167
f: impl FnOnce(&mut EvalCtxt<'_, 'tcx>) -> R,
171168
) -> (R, Option<inspect::GoalEvaluation<'tcx>>) {
172169
let mode = if infcx.intercrate { SolverMode::Coherence } else { SolverMode::Normal };
173-
let mut search_graph = search_graph::SearchGraph::new(infcx.tcx, mode);
170+
let mut search_graph = search_graph::SearchGraph::new(mode);
174171

175172
let mut ecx = EvalCtxt {
176173
search_graph: &mut search_graph,
@@ -404,16 +401,18 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
404401
&& source != GoalSource::ImplWhereBound
405402
};
406403

407-
if response.value.certainty == Certainty::OVERFLOW && !keep_overflow_constraints() {
408-
Ok((Certainty::OVERFLOW, false, Vec::new()))
409-
} else {
410-
let has_changed = !response.value.var_values.is_identity_modulo_regions()
411-
|| !response.value.external_constraints.opaque_types.is_empty();
412-
413-
let (certainty, nested_goals) =
414-
self.instantiate_and_apply_query_response(param_env, original_values, response)?;
415-
Ok((certainty, has_changed, nested_goals))
404+
if let Certainty::Maybe(MaybeCause::Overflow { .. }) = response.value.certainty
405+
&& !keep_overflow_constraints()
406+
{
407+
return Ok((response.value.certainty, false, Vec::new()));
416408
}
409+
410+
let has_changed = !response.value.var_values.is_identity_modulo_regions()
411+
|| !response.value.external_constraints.opaque_types.is_empty();
412+
413+
let (certainty, nested_goals) =
414+
self.instantiate_and_apply_query_response(param_env, original_values, response)?;
415+
Ok((certainty, has_changed, nested_goals))
417416
}
418417

419418
fn compute_goal(&mut self, goal: Goal<'tcx, ty::Predicate<'tcx>>) -> QueryResult<'tcx> {
@@ -482,8 +481,8 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
482481
let inspect = self.inspect.new_evaluate_added_goals();
483482
let inspect = core::mem::replace(&mut self.inspect, inspect);
484483

485-
let mut response = Ok(Certainty::OVERFLOW);
486-
for _ in 0..self.local_overflow_limit() {
484+
let mut response = Ok(Certainty::overflow(false));
485+
for _ in 0..FIXPOINT_STEP_LIMIT {
487486
// FIXME: This match is a bit ugly, it might be nice to change the inspect
488487
// stuff to use a closure instead. which should hopefully simplify this a bit.
489488
match self.evaluate_added_goals_step() {

‎compiler/rustc_trait_selection/src/solve/fulfill.rs

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -81,11 +81,15 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
8181
.0
8282
{
8383
Ok((_, Certainty::Maybe(MaybeCause::Ambiguity), _)) => {
84-
FulfillmentErrorCode::Ambiguity { overflow: false }
85-
}
86-
Ok((_, Certainty::Maybe(MaybeCause::Overflow), _)) => {
87-
FulfillmentErrorCode::Ambiguity { overflow: true }
84+
FulfillmentErrorCode::Ambiguity { overflow: None }
8885
}
86+
Ok((
87+
_,
88+
Certainty::Maybe(MaybeCause::Overflow { suggest_increasing_limit }),
89+
_,
90+
)) => FulfillmentErrorCode::Ambiguity {
91+
overflow: Some(suggest_increasing_limit),
92+
},
8993
Ok((_, Certainty::Yes, _)) => {
9094
bug!("did not expect successful goal when collecting ambiguity errors")
9195
}

‎compiler/rustc_trait_selection/src/solve/mod.rs

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,17 @@ pub use fulfill::FulfillmentCtxt;
4242
pub(crate) use normalize::deeply_normalize_for_diagnostics;
4343
pub use normalize::{deeply_normalize, deeply_normalize_with_skipped_universes};
4444

45+
/// How many fixpoint iterations we should attempt inside of the solver before bailing
46+
/// with overflow.
47+
///
48+
/// We previously used `tcx.recursion_limit().0.checked_ilog2().unwrap_or(0)` for this.
49+
/// However, it feels unlikely that uncreasing the recursion limit by a power of two
50+
/// to get one more itereation is every useful or desirable. We now instead used a constant
51+
/// here. If there ever ends up some use-cases where a bigger number of fixpoint iterations
52+
/// is required, we can add a new attribute for that or revert this to be dependant on the
53+
/// recursion limit again. However, this feels very unlikely.
54+
const FIXPOINT_STEP_LIMIT: usize = 8;
55+
4556
#[derive(Debug, Clone, Copy)]
4657
enum SolverMode {
4758
/// Ordinary trait solving, using everywhere except for coherence.

‎compiler/rustc_trait_selection/src/solve/search_graph.rs

Lines changed: 9 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
use crate::solve::FIXPOINT_STEP_LIMIT;
2+
13
use super::inspect;
24
use super::inspect::ProofTreeBuilder;
35
use super::SolverMode;
@@ -99,7 +101,6 @@ impl<'tcx> ProvisionalCacheEntry<'tcx> {
99101

100102
pub(super) struct SearchGraph<'tcx> {
101103
mode: SolverMode,
102-
local_overflow_limit: usize,
103104
/// The stack of goals currently being computed.
104105
///
105106
/// An element is *deeper* in the stack if its index is *lower*.
@@ -116,10 +117,9 @@ pub(super) struct SearchGraph<'tcx> {
116117
}
117118

118119
impl<'tcx> SearchGraph<'tcx> {
119-
pub(super) fn new(tcx: TyCtxt<'tcx>, mode: SolverMode) -> SearchGraph<'tcx> {
120+
pub(super) fn new(mode: SolverMode) -> SearchGraph<'tcx> {
120121
Self {
121122
mode,
122-
local_overflow_limit: tcx.recursion_limit().0.checked_ilog2().unwrap_or(0) as usize,
123123
stack: Default::default(),
124124
provisional_cache: Default::default(),
125125
cycle_participants: Default::default(),
@@ -130,10 +130,6 @@ impl<'tcx> SearchGraph<'tcx> {
130130
self.mode
131131
}
132132

133-
pub(super) fn local_overflow_limit(&self) -> usize {
134-
self.local_overflow_limit
135-
}
136-
137133
/// Update the stack and reached depths on cache hits.
138134
#[instrument(level = "debug", skip(self))]
139135
fn on_cache_hit(&mut self, additional_depth: usize, encountered_overflow: bool) {
@@ -277,7 +273,7 @@ impl<'tcx> SearchGraph<'tcx> {
277273
}
278274

279275
inspect.goal_evaluation_kind(inspect::WipCanonicalGoalEvaluationKind::Overflow);
280-
return Self::response_no_constraints(tcx, input, Certainty::OVERFLOW);
276+
return Self::response_no_constraints(tcx, input, Certainty::overflow(true));
281277
};
282278

283279
// Try to fetch the goal from the global cache.
@@ -370,7 +366,7 @@ impl<'tcx> SearchGraph<'tcx> {
370366
} else if is_coinductive_cycle {
371367
Self::response_no_constraints(tcx, input, Certainty::Yes)
372368
} else {
373-
Self::response_no_constraints(tcx, input, Certainty::OVERFLOW)
369+
Self::response_no_constraints(tcx, input, Certainty::overflow(false))
374370
};
375371
} else {
376372
// No entry, we push this goal on the stack and try to prove it.
@@ -398,7 +394,7 @@ impl<'tcx> SearchGraph<'tcx> {
398394
// of this we continuously recompute the cycle until the result
399395
// of the previous iteration is equal to the final result, at which
400396
// point we are done.
401-
for _ in 0..self.local_overflow_limit() {
397+
for _ in 0..FIXPOINT_STEP_LIMIT {
402398
let result = prove_goal(self, inspect);
403399
let stack_entry = self.pop_stack();
404400
debug_assert_eq!(stack_entry.input, input);
@@ -431,7 +427,8 @@ impl<'tcx> SearchGraph<'tcx> {
431427
} else if stack_entry.has_been_used == HasBeenUsed::COINDUCTIVE_CYCLE {
432428
Self::response_no_constraints(tcx, input, Certainty::Yes) == result
433429
} else if stack_entry.has_been_used == HasBeenUsed::INDUCTIVE_CYCLE {
434-
Self::response_no_constraints(tcx, input, Certainty::OVERFLOW) == result
430+
Self::response_no_constraints(tcx, input, Certainty::overflow(false))
431+
== result
435432
} else {
436433
false
437434
};
@@ -452,7 +449,7 @@ impl<'tcx> SearchGraph<'tcx> {
452449
debug!("canonical cycle overflow");
453450
let current_entry = self.pop_stack();
454451
debug_assert!(current_entry.has_been_used.is_empty());
455-
let result = Self::response_no_constraints(tcx, input, Certainty::OVERFLOW);
452+
let result = Self::response_no_constraints(tcx, input, Certainty::overflow(false));
456453
(current_entry, result)
457454
});
458455

‎compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -335,12 +335,16 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
335335
);
336336
}
337337

338-
fn report_overflow_no_abort(&self, obligation: PredicateObligation<'tcx>) -> ErrorGuaranteed {
338+
fn report_overflow_no_abort(
339+
&self,
340+
obligation: PredicateObligation<'tcx>,
341+
suggest_increasing_limit: bool,
342+
) -> ErrorGuaranteed {
339343
let obligation = self.resolve_vars_if_possible(obligation);
340344
let mut err = self.build_overflow_error(
341345
OverflowCause::TraitSolver(obligation.predicate),
342346
obligation.cause.span,
343-
true,
347+
suggest_increasing_limit,
344348
);
345349
self.note_obligation_cause(&mut err, &obligation);
346350
self.point_at_returns_when_relevant(&mut err, &obligation);
@@ -1422,11 +1426,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
14221426
FulfillmentErrorCode::ProjectionError(ref e) => {
14231427
self.report_projection_error(&error.obligation, e)
14241428
}
1425-
FulfillmentErrorCode::Ambiguity { overflow: false } => {
1429+
FulfillmentErrorCode::Ambiguity { overflow: None } => {
14261430
self.maybe_report_ambiguity(&error.obligation)
14271431
}
1428-
FulfillmentErrorCode::Ambiguity { overflow: true } => {
1429-
self.report_overflow_no_abort(error.obligation.clone())
1432+
FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) } => {
1433+
self.report_overflow_no_abort(error.obligation.clone(), suggest_increasing_limit)
14301434
}
14311435
FulfillmentErrorCode::SubtypeError(ref expected_found, ref err) => self
14321436
.report_mismatched_types(

‎compiler/rustc_trait_selection/src/traits/fulfill.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,7 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
138138
_infcx: &InferCtxt<'tcx>,
139139
) -> Vec<FulfillmentError<'tcx>> {
140140
self.predicates
141-
.to_errors(FulfillmentErrorCode::Ambiguity { overflow: false })
141+
.to_errors(FulfillmentErrorCode::Ambiguity { overflow: None })
142142
.into_iter()
143143
.map(to_fulfillment_error)
144144
.collect()

‎tests/ui/higher-ranked/trait-bounds/issue-95230.next.stderr

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,6 @@ error[E0275]: overflow evaluating the requirement `for<'a> &'a mut Bar well-form
44
LL | for<'a> &'a mut Self:;
55
| ^^^^^^^^^^^^
66
|
7-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`issue_95230`)
87
note: required by a bound in `Bar`
98
--> $DIR/issue-95230.rs:9:13
109
|

‎tests/ui/traits/next-solver/alias-bound-unsound.stderr

Lines changed: 0 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,6 @@ error[E0275]: overflow evaluating the requirement `String: Copy`
44
LL | type Item = String where String: Copy;
55
| ^^^^
66
|
7-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
87
note: the requirement `String: Copy` appears on the `impl`'s associated type `Item` but not on the corresponding trait's associated type
98
--> $DIR/alias-bound-unsound.rs:8:10
109
|
@@ -18,40 +17,31 @@ error[E0275]: overflow evaluating the requirement `String <: <() as Foo>::Item`
1817
|
1918
LL | drop(<() as Foo>::copy_me(&x));
2019
| ^^
21-
|
22-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
2320

2421
error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
2522
--> $DIR/alias-bound-unsound.rs:24:10
2623
|
2724
LL | drop(<() as Foo>::copy_me(&x));
2825
| ^^^^^^^^^^^^^^^^^^^^^^^^
29-
|
30-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
3126

3227
error[E0275]: overflow evaluating the requirement `&<() as Foo>::Item well-formed`
3328
--> $DIR/alias-bound-unsound.rs:24:31
3429
|
3530
LL | drop(<() as Foo>::copy_me(&x));
3631
| ^^
37-
|
38-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
3932

4033
error[E0275]: overflow evaluating the requirement `<() as Foo>::Item well-formed`
4134
--> $DIR/alias-bound-unsound.rs:24:10
4235
|
4336
LL | drop(<() as Foo>::copy_me(&x));
4437
| ^^^^^^^^^^^^^^^^^^^^^^^^
45-
|
46-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
4738

4839
error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
4940
--> $DIR/alias-bound-unsound.rs:24:10
5041
|
5142
LL | drop(<() as Foo>::copy_me(&x));
5243
| ^^^^^^^^^^^^^^^^^^^^^^^^
5344
|
54-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`alias_bound_unsound`)
5545
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
5646

5747
error: aborting due to 6 previous errors

‎tests/ui/traits/next-solver/coherence/trait_ref_is_knowable-norm-overflow.stderr

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,6 @@ error[E0275]: overflow evaluating the requirement `<T as Overflow>::Assoc: Sized
1313
LL | type Assoc = <T as Overflow>::Assoc;
1414
| ^^^^^^^^^^^^^^^^^^^^^^
1515
|
16-
= help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`trait_ref_is_knowable_norm_overflow`)
1716
note: required by a bound in `Overflow::Assoc`
1817
--> $DIR/trait_ref_is_knowable-norm-overflow.rs:7:5
1918
|

0 commit comments

Comments
 (0)