Skip to content

Commit f943f73

Browse files
compiler-errorscompiler-errors
committed
More
1 parent 7c1661f commit f943f73

File tree

19 files changed

+189
-187
lines changed

19 files changed

+189
-187
lines changed

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

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -967,7 +967,9 @@ impl<'tcx> InferCtxt<'tcx> {
967967
pub fn can_define_opaque_ty(&self, id: impl Into<DefId>) -> bool {
968968
debug_assert!(!self.next_trait_solver());
969969
match self.typing_mode() {
970-
TypingMode::Analysis { defining_opaque_types, stalled_generators: _ }
970+
TypingMode::Analysis {
971+
defining_opaque_types_and_generators: defining_opaque_types,
972+
}
971973
| TypingMode::Borrowck { defining_opaque_types } => {
972974
id.into().as_local().is_some_and(|def_id| defining_opaque_types.contains(&def_id))
973975
}
@@ -1262,7 +1264,7 @@ impl<'tcx> InferCtxt<'tcx> {
12621264
// to handle them without proper canonicalization. This means we may cause cycle
12631265
// errors and fail to reveal opaques while inside of bodies. We should rename this
12641266
// function and require explicit comments on all use-sites in the future.
1265-
ty::TypingMode::Analysis { defining_opaque_types: _, stalled_generators: _ }
1267+
ty::TypingMode::Analysis { defining_opaque_types_and_generators: _ }
12661268
| ty::TypingMode::Borrowck { defining_opaque_types: _ } => {
12671269
TypingMode::non_body_analysis()
12681270
}

‎compiler/rustc_middle/src/query/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -391,7 +391,7 @@ rustc_queries! {
391391
key: LocalDefId
392392
) -> &'tcx ty::List<LocalDefId> {
393393
desc {
394-
|tcx| "computing the opaque types defined by `{}`",
394+
|tcx| "computing the coroutines defined within `{}`",
395395
tcx.def_path_str(key.to_def_id())
396396
}
397397
}

‎compiler/rustc_middle/src/query/plumbing.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -366,11 +366,11 @@ macro_rules! define_callbacks {
366366

367367
pub type Storage<'tcx> = <$($K)* as keys::Key>::Cache<Erase<$V>>;
368368

369-
// Ensure that keys grow no larger than 96 bytes by accident.
369+
// Ensure that keys grow no larger than 88 bytes by accident.
370370
// Increase this limit if necessary, but do try to keep the size low if possible
371371
#[cfg(target_pointer_width = "64")]
372372
const _: () = {
373-
if size_of::<Key<'static>>() > 96 {
373+
if size_of::<Key<'static>>() > 88 {
374374
panic!("{}", concat!(
375375
"the query `",
376376
stringify!($name),

‎compiler/rustc_middle/src/ty/context.rs

Lines changed: 12 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -678,11 +678,18 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
678678
self.opaque_types_defined_by(defining_anchor)
679679
}
680680

681-
fn stalled_generators_within(self, defining_anchor: Self::LocalDefId) -> Self::LocalDefIds {
681+
fn opaque_types_and_generators_defined_by(
682+
self,
683+
defining_anchor: Self::LocalDefId,
684+
) -> Self::LocalDefIds {
682685
if self.next_trait_solver_globally() {
683-
self.stalled_generators_within(defining_anchor)
686+
self.mk_local_def_ids_from_iter(
687+
self.opaque_types_defined_by(defining_anchor)
688+
.iter()
689+
.chain(self.stalled_generators_within(defining_anchor)),
690+
)
684691
} else {
685-
ty::List::empty()
692+
self.opaque_types_defined_by(defining_anchor)
686693
}
687694
}
688695
}
@@ -2914,11 +2921,11 @@ impl<'tcx> TyCtxt<'tcx> {
29142921
self.interners.intern_clauses(clauses)
29152922
}
29162923

2917-
pub fn mk_local_def_ids(self, clauses: &[LocalDefId]) -> &'tcx List<LocalDefId> {
2924+
pub fn mk_local_def_ids(self, def_ids: &[LocalDefId]) -> &'tcx List<LocalDefId> {
29182925
// FIXME consider asking the input slice to be sorted to avoid
29192926
// re-interning permutations, in which case that would be asserted
29202927
// here.
2921-
self.intern_local_def_ids(clauses)
2928+
self.intern_local_def_ids(def_ids)
29222929
}
29232930

29242931
pub fn mk_local_def_ids_from_iter<I, T>(self, iter: I) -> T::Output

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

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -329,10 +329,7 @@ where
329329
TypingMode::Coherence | TypingMode::PostAnalysis => false,
330330
// During analysis, opaques are rigid unless they may be defined by
331331
// the current body.
332-
TypingMode::Analysis {
333-
defining_opaque_types: non_rigid_opaques,
334-
stalled_generators: _,
335-
}
332+
TypingMode::Analysis { defining_opaque_types_and_generators: non_rigid_opaques }
336333
| TypingMode::Borrowck { defining_opaque_types: non_rigid_opaques }
337334
| TypingMode::PostBorrowckAnalysis { defined_opaque_types: non_rigid_opaques } => {
338335
!def_id.as_local().is_some_and(|def_id| non_rigid_opaques.contains(&def_id))

‎compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -33,11 +33,11 @@ where
3333
);
3434
self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
3535
}
36-
TypingMode::Analysis { defining_opaque_types, stalled_generators: _ } => {
36+
TypingMode::Analysis { defining_opaque_types_and_generators } => {
3737
let Some(def_id) = opaque_ty
3838
.def_id
3939
.as_local()
40-
.filter(|&def_id| defining_opaque_types.contains(&def_id))
40+
.filter(|&def_id| defining_opaque_types_and_generators.contains(&def_id))
4141
else {
4242
self.structurally_instantiate_normalizes_to_term(goal, goal.predicate.alias);
4343
return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);

‎compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

Lines changed: 30 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -208,20 +208,9 @@ where
208208
}
209209
}
210210

211-
// TODO:
212-
if let ty::CoroutineWitness(def_id, _) = goal.predicate.self_ty().kind() {
213-
match ecx.typing_mode() {
214-
TypingMode::Analysis { stalled_generators, defining_opaque_types: _ } => {
215-
if def_id.as_local().is_some_and(|def_id| stalled_generators.contains(&def_id))
216-
{
217-
return ecx.forced_ambiguity(MaybeCause::Ambiguity);
218-
}
219-
}
220-
TypingMode::Coherence
221-
| TypingMode::PostAnalysis
222-
| TypingMode::Borrowck { defining_opaque_types: _ }
223-
| TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ } => {}
224-
}
211+
// We need to make sure to stall any coroutines we are inferring to avoid query cycles.
212+
if let Some(cand) = ecx.try_stall_coroutine_witness(goal.predicate.self_ty()) {
213+
return cand;
225214
}
226215

227216
ecx.probe_and_evaluate_goal_for_constituent_tys(
@@ -275,20 +264,9 @@ where
275264
return Err(NoSolution);
276265
}
277266

278-
// TODO:
279-
if let ty::CoroutineWitness(def_id, _) = goal.predicate.self_ty().kind() {
280-
match ecx.typing_mode() {
281-
TypingMode::Analysis { stalled_generators, defining_opaque_types: _ } => {
282-
if def_id.as_local().is_some_and(|def_id| stalled_generators.contains(&def_id))
283-
{
284-
return ecx.forced_ambiguity(MaybeCause::Ambiguity);
285-
}
286-
}
287-
TypingMode::Coherence
288-
| TypingMode::PostAnalysis
289-
| TypingMode::Borrowck { defining_opaque_types: _ }
290-
| TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ } => {}
291-
}
267+
// We need to make sure to stall any coroutines we are inferring to avoid query cycles.
268+
if let Some(cand) = ecx.try_stall_coroutine_witness(goal.predicate.self_ty()) {
269+
return cand;
292270
}
293271

294272
ecx.probe_and_evaluate_goal_for_constituent_tys(
@@ -1400,4 +1378,28 @@ where
14001378
let candidates = self.assemble_and_evaluate_candidates(goal, AssembleCandidatesFrom::All);
14011379
self.merge_trait_candidates(goal, candidates)
14021380
}
1381+
1382+
fn try_stall_coroutine_witness(
1383+
&mut self,
1384+
self_ty: I::Ty,
1385+
) -> Option<Result<Candidate<I>, NoSolution>> {
1386+
if let ty::CoroutineWitness(def_id, _) = self_ty.kind() {
1387+
match self.typing_mode() {
1388+
TypingMode::Analysis {
1389+
defining_opaque_types_and_generators: stalled_generators,
1390+
} => {
1391+
if def_id.as_local().is_some_and(|def_id| stalled_generators.contains(&def_id))
1392+
{
1393+
return Some(self.forced_ambiguity(MaybeCause::Ambiguity));
1394+
}
1395+
}
1396+
TypingMode::Coherence
1397+
| TypingMode::PostAnalysis
1398+
| TypingMode::Borrowck { defining_opaque_types: _ }
1399+
| TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ } => {}
1400+
}
1401+
}
1402+
1403+
None
1404+
}
14031405
}

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

Lines changed: 32 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@ use rustc_middle::ty::{
1414
};
1515
use rustc_next_trait_solver::solve::{GenerateProofTree, HasChanged, SolverDelegateEvalExt as _};
1616
use rustc_span::Span;
17+
use rustc_type_ir::data_structures::DelayedSet;
1718
use tracing::instrument;
1819

1920
use self::derive_errors::*;
@@ -217,37 +218,49 @@ where
217218
&mut self,
218219
infcx: &InferCtxt<'tcx>,
219220
) -> PredicateObligations<'tcx> {
220-
self.obligations.drain_pending(|obl| {
221-
let stalled_generators = match infcx.typing_mode() {
222-
TypingMode::Analysis { defining_opaque_types: _, stalled_generators } => {
223-
stalled_generators
224-
}
225-
TypingMode::Coherence
226-
| TypingMode::Borrowck { defining_opaque_types: _ }
227-
| TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ }
228-
| TypingMode::PostAnalysis => return false,
229-
};
230-
231-
if stalled_generators.is_empty() {
232-
return false;
221+
let stalled_generators = match infcx.typing_mode() {
222+
TypingMode::Analysis { defining_opaque_types_and_generators } => {
223+
defining_opaque_types_and_generators
233224
}
225+
TypingMode::Coherence
226+
| TypingMode::Borrowck { defining_opaque_types: _ }
227+
| TypingMode::PostBorrowckAnalysis { defined_opaque_types: _ }
228+
| TypingMode::PostAnalysis => return Default::default(),
229+
};
230+
231+
if stalled_generators.is_empty() {
232+
return Default::default();
233+
}
234234

235+
self.obligations.drain_pending(|obl| {
235236
infcx.probe(|_| {
236237
infcx
237238
.visit_proof_tree(
238239
obl.as_goal(),
239-
&mut StalledOnCoroutines { stalled_generators, span: obl.cause.span },
240+
&mut StalledOnCoroutines {
241+
stalled_generators,
242+
span: obl.cause.span,
243+
cache: Default::default(),
244+
},
240245
)
241246
.is_break()
242247
})
243248
})
244249
}
245250
}
246251

252+
/// Detect if a goal is stalled on a coroutine that is owned by the current typeck root.
253+
///
254+
/// This function can (erroneously) fail to detect a predicate, i.e. it doesn't need to
255+
/// be complete. However, this will lead to ambiguity errors, so we want to make it
256+
/// accurate.
257+
///
258+
/// This function can be also return false positives, which will lead to poor diagnostics
259+
/// so we want to keep this visitor *precise* too.
247260
struct StalledOnCoroutines<'tcx> {
248261
stalled_generators: &'tcx ty::List<LocalDefId>,
249262
span: Span,
250-
// TODO: Cache
263+
cache: DelayedSet<Ty<'tcx>>,
251264
}
252265

253266
impl<'tcx> inspect::ProofTreeVisitor<'tcx> for StalledOnCoroutines<'tcx> {
@@ -272,6 +285,10 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for StalledOnCoroutines<'tcx> {
272285
type Result = ControlFlow<()>;
273286

274287
fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
288+
if !self.cache.insert(ty) {
289+
return ControlFlow::Continue(());
290+
}
291+
275292
if let ty::CoroutineWitness(def_id, _) = *ty.kind()
276293
&& def_id.as_local().is_some_and(|def_id| self.stalled_generators.contains(&def_id))
277294
{

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

Lines changed: 27 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
use std::assert_matches::assert_matches;
22
use std::fmt::Debug;
3-
use std::marker::PhantomData;
43

54
use rustc_data_structures::stack::ensure_sufficient_stack;
65
use rustc_infer::infer::InferCtxt;
@@ -60,7 +59,8 @@ where
6059
/// entered before passing `value` to the function. This is currently needed for
6160
/// `normalize_erasing_regions`, which skips binders as it walks through a type.
6261
///
63-
/// TODO: doc
62+
/// This returns a set of stalled obligations if the typing mode of the underlying infcx
63+
/// has any stalled coroutine def ids.
6464
pub fn deeply_normalize_with_skipped_universes_and_ambiguous_goals<'tcx, T, E>(
6565
at: At<'_, 'tcx>,
6666
value: T,
@@ -72,24 +72,18 @@ where
7272
{
7373
let fulfill_cx = FulfillmentCtxt::new(at.infcx);
7474
let mut folder =
75-
NormalizationFolder { at, fulfill_cx, depth: 0, universes, _errors: PhantomData };
75+
NormalizationFolder { at, fulfill_cx, depth: 0, universes, stalled_goals: vec![] };
7676
let value = value.try_fold_with(&mut folder)?;
77-
let goals = folder
78-
.fulfill_cx
79-
.drain_stalled_obligations_for_coroutines(at.infcx)
80-
.into_iter()
81-
.map(|obl| obl.as_goal())
82-
.collect();
8377
let errors = folder.fulfill_cx.select_all_or_error(at.infcx);
84-
if errors.is_empty() { Ok((value, goals)) } else { Err(errors) }
78+
if errors.is_empty() { Ok((value, folder.stalled_goals)) } else { Err(errors) }
8579
}
8680

8781
struct NormalizationFolder<'me, 'tcx, E> {
8882
at: At<'me, 'tcx>,
8983
fulfill_cx: FulfillmentCtxt<'tcx, E>,
9084
depth: usize,
9185
universes: Vec<Option<UniverseIndex>>,
92-
_errors: PhantomData<E>,
86+
stalled_goals: Vec<Goal<'tcx, ty::Predicate<'tcx>>>,
9387
}
9488

9589
impl<'tcx, E> NormalizationFolder<'_, 'tcx, E>
@@ -130,10 +124,7 @@ where
130124
);
131125

132126
self.fulfill_cx.register_predicate_obligation(infcx, obligation);
133-
let errors = self.fulfill_cx.select_where_possible(infcx);
134-
if !errors.is_empty() {
135-
return Err(errors);
136-
}
127+
self.select_all_and_stall_coroutine_predicates()?;
137128

138129
// Alias is guaranteed to be fully structurally resolved,
139130
// so we can super fold here.
@@ -184,6 +175,27 @@ where
184175
self.depth -= 1;
185176
Ok(result)
186177
}
178+
179+
fn select_all_and_stall_coroutine_predicates(&mut self) -> Result<(), Vec<E>> {
180+
let errors = self.fulfill_cx.select_where_possible(self.at.infcx);
181+
if !errors.is_empty() {
182+
return Err(errors);
183+
}
184+
185+
self.stalled_goals.extend(
186+
self.fulfill_cx
187+
.drain_stalled_obligations_for_coroutines(self.at.infcx)
188+
.into_iter()
189+
.map(|obl| obl.as_goal()),
190+
);
191+
192+
let errors = self.fulfill_cx.collect_remaining_errors(self.at.infcx);
193+
if !errors.is_empty() {
194+
return Err(errors);
195+
}
196+
197+
Ok(())
198+
}
187199
}
188200

189201
impl<'tcx, E> FallibleTypeFolder<TyCtxt<'tcx>> for NormalizationFolder<'_, 'tcx, E>

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

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1498,7 +1498,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
14981498
// However, if we disqualify *all* goals from being cached, perf suffers.
14991499
// This is likely fixed by better caching in general in the new solver.
15001500
// See: <https://github.com/rust-lang/rust/issues/132064>.
1501-
TypingMode::Analysis { defining_opaque_types, stalled_generators: _ }
1501+
TypingMode::Analysis {
1502+
defining_opaque_types_and_generators: defining_opaque_types,
1503+
}
15021504
| TypingMode::Borrowck { defining_opaque_types } => {
15031505
defining_opaque_types.is_empty() || !pred.has_opaque_types()
15041506
}

‎compiler/rustc_ty_utils/src/lib.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@ mod needs_drop;
3232
mod opaque_types;
3333
mod representability;
3434
pub mod sig_types;
35+
mod stalled_generators;
3536
mod structural_match;
3637
mod ty;
3738

@@ -50,4 +51,5 @@ pub fn provide(providers: &mut Providers) {
5051
ty::provide(providers);
5152
instance::provide(providers);
5253
structural_match::provide(providers);
54+
stalled_generators::provide(providers);
5355
}

0 commit comments

Comments
 (0)