Skip to content

Commit c5270f4

Browse files
compiler-errorscompiler-errors
committed
Rework var resolution in InferCtxtLike, uplift EagerResolver
1 parent ba6c2b5 commit c5270f4

10 files changed

Lines changed: 191 additions & 159 deletions

File tree

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

Lines changed: 27 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -369,33 +369,43 @@ impl<'tcx> ty::InferCtxtLike for InferCtxt<'tcx> {
369369
}
370370
}
371371

372-
fn root_ty_var(&self, vid: TyVid) -> TyVid {
373-
self.root_var(vid)
372+
fn opportunistic_resolve_lt_var(&self, vid: ty::RegionVid) -> ty::Region<'tcx> {
373+
self.inner.borrow_mut().unwrap_region_constraints().opportunistic_resolve_var(self.tcx, vid)
374374
}
375375

376-
fn probe_ty_var(&self, vid: TyVid) -> Option<Ty<'tcx>> {
377-
self.probe_ty_var(vid).ok()
376+
fn defining_opaque_types(&self) -> &'tcx ty::List<LocalDefId> {
377+
self.defining_opaque_types
378378
}
379379

380-
fn opportunistic_resolve_lt_var(&self, vid: ty::RegionVid) -> Option<ty::Region<'tcx>> {
381-
let re = self
382-
.inner
383-
.borrow_mut()
384-
.unwrap_region_constraints()
385-
.opportunistic_resolve_var(self.tcx, vid);
386-
if *re == ty::ReVar(vid) { None } else { Some(re) }
380+
fn opportunistic_resolve_ty_var(&self, vid: TyVid) -> Ty<'tcx> {
381+
match self.probe_ty_var(vid) {
382+
Ok(ty) => ty,
383+
Err(_) => Ty::new_var(self.tcx, self.root_var(vid)),
384+
}
387385
}
388386

389-
fn root_ct_var(&self, vid: ConstVid) -> ConstVid {
390-
self.root_const_var(vid)
387+
fn opportunistic_resolve_int_var(&self, vid: IntVid) -> Ty<'tcx> {
388+
self.opportunistic_resolve_int_var(vid)
391389
}
392390

393-
fn probe_ct_var(&self, vid: ConstVid) -> Option<ty::Const<'tcx>> {
394-
self.probe_const_var(vid).ok()
391+
fn opportunistic_resolve_float_var(&self, vid: FloatVid) -> Ty<'tcx> {
392+
self.opportunistic_resolve_float_var(vid)
395393
}
396394

397-
fn defining_opaque_types(&self) -> &'tcx ty::List<LocalDefId> {
398-
self.defining_opaque_types
395+
fn opportunistic_resolve_ct_var(&self, vid: ConstVid, ty: Ty<'tcx>) -> ty::Const<'tcx> {
396+
match self.probe_const_var(vid) {
397+
Ok(ct) => ct,
398+
Err(_) => ty::Const::new_var(self.tcx, self.root_const_var(vid), ty),
399+
}
400+
}
401+
402+
fn opportunistic_resolve_effect_var(&self, vid: EffectVid, ty: Ty<'tcx>) -> ty::Const<'tcx> {
403+
match self.probe_effect_var(vid) {
404+
Some(ct) => ct,
405+
None => {
406+
ty::Const::new_infer(self.tcx, InferConst::EffectVar(self.root_effect_var(vid)), ty)
407+
}
408+
}
399409
}
400410
}
401411

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

Lines changed: 0 additions & 81 deletions
Original file line numberDiff line numberDiff line change
@@ -173,84 +173,3 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for FullTypeResolver<'a, 'tcx> {
173173
}
174174
}
175175
}
176-
177-
///////////////////////////////////////////////////////////////////////////
178-
// EAGER RESOLUTION
179-
180-
/// Resolves ty, region, and const vars to their inferred values or their root vars.
181-
pub struct EagerResolver<'a, 'tcx> {
182-
infcx: &'a InferCtxt<'tcx>,
183-
}
184-
185-
impl<'a, 'tcx> EagerResolver<'a, 'tcx> {
186-
pub fn new(infcx: &'a InferCtxt<'tcx>) -> Self {
187-
EagerResolver { infcx }
188-
}
189-
}
190-
191-
impl<'tcx> TypeFolder<TyCtxt<'tcx>> for EagerResolver<'_, 'tcx> {
192-
fn interner(&self) -> TyCtxt<'tcx> {
193-
self.infcx.tcx
194-
}
195-
196-
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
197-
match *t.kind() {
198-
ty::Infer(ty::TyVar(vid)) => match self.infcx.probe_ty_var(vid) {
199-
Ok(t) => t.fold_with(self),
200-
Err(_) => Ty::new_var(self.infcx.tcx, self.infcx.root_var(vid)),
201-
},
202-
ty::Infer(ty::IntVar(vid)) => self.infcx.opportunistic_resolve_int_var(vid),
203-
ty::Infer(ty::FloatVar(vid)) => self.infcx.opportunistic_resolve_float_var(vid),
204-
_ => {
205-
if t.has_infer() {
206-
t.super_fold_with(self)
207-
} else {
208-
t
209-
}
210-
}
211-
}
212-
}
213-
214-
fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
215-
match *r {
216-
ty::ReVar(vid) => self
217-
.infcx
218-
.inner
219-
.borrow_mut()
220-
.unwrap_region_constraints()
221-
.opportunistic_resolve_var(self.infcx.tcx, vid),
222-
_ => r,
223-
}
224-
}
225-
226-
fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
227-
match c.kind() {
228-
ty::ConstKind::Infer(ty::InferConst::Var(vid)) => {
229-
// FIXME: we need to fold the ty too, I think.
230-
match self.infcx.probe_const_var(vid) {
231-
Ok(c) => c.fold_with(self),
232-
Err(_) => {
233-
ty::Const::new_var(self.infcx.tcx, self.infcx.root_const_var(vid), c.ty())
234-
}
235-
}
236-
}
237-
ty::ConstKind::Infer(ty::InferConst::EffectVar(vid)) => {
238-
debug_assert_eq!(c.ty(), self.infcx.tcx.types.bool);
239-
self.infcx.probe_effect_var(vid).unwrap_or_else(|| {
240-
ty::Const::new_infer(
241-
self.infcx.tcx,
242-
ty::InferConst::EffectVar(self.infcx.root_effect_var(vid)),
243-
self.infcx.tcx.types.bool,
244-
)
245-
})
246-
}
247-
_ => {
248-
if c.has_infer() {
249-
c.super_fold_with(self)
250-
} else {
251-
c
252-
}
253-
}
254-
}
255-
}
256-
}

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

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -175,6 +175,14 @@ impl<'tcx> Const<'tcx> {
175175
}
176176

177177
impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
178+
fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferConst, ty: Ty<'tcx>) -> Self {
179+
Const::new_infer(tcx, infer, ty)
180+
}
181+
182+
fn new_var(tcx: TyCtxt<'tcx>, vid: ty::ConstVid, ty: Ty<'tcx>) -> Self {
183+
Const::new_var(tcx, vid, ty)
184+
}
185+
178186
fn new_anon_bound(
179187
tcx: TyCtxt<'tcx>,
180188
debruijn: ty::DebruijnIndex,

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

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1611,6 +1611,14 @@ impl<'tcx> rustc_type_ir::inherent::Ty<TyCtxt<'tcx>> for Ty<'tcx> {
16111611
tcx.types.bool
16121612
}
16131613

1614+
fn new_infer(tcx: TyCtxt<'tcx>, infer: ty::InferTy) -> Self {
1615+
Ty::new_infer(tcx, infer)
1616+
}
1617+
1618+
fn new_var(tcx: TyCtxt<'tcx>, vid: ty::TyVid) -> Self {
1619+
Ty::new_var(tcx, vid)
1620+
}
1621+
16141622
fn new_anon_bound(tcx: TyCtxt<'tcx>, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self {
16151623
Ty::new_bound(tcx, debruijn, ty::BoundTy { var, kind: ty::BoundTyKind::Anon })
16161624
}

‎compiler/rustc_next_trait_solver/src/canonicalizer.rs‎

Lines changed: 101 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -268,7 +268,7 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
268268
ty::ReVar(vid) => {
269269
assert_eq!(
270270
self.infcx.opportunistic_resolve_lt_var(vid),
271-
None,
271+
r,
272272
"region vid should have been resolved fully before canonicalization"
273273
);
274274
match self.canonicalize_mode {
@@ -302,13 +302,8 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
302302
ty::Infer(i) => match i {
303303
ty::TyVar(vid) => {
304304
assert_eq!(
305-
self.infcx.root_ty_var(vid),
306-
vid,
307-
"ty vid should have been resolved fully before canonicalization"
308-
);
309-
assert_eq!(
310-
self.infcx.probe_ty_var(vid),
311-
None,
305+
self.infcx.opportunistic_resolve_ty_var(vid),
306+
t,
312307
"ty vid should have been resolved fully before canonicalization"
313308
);
314309

@@ -318,10 +313,24 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
318313
.unwrap_or_else(|| panic!("ty var should have been resolved: {t:?}")),
319314
))
320315
}
321-
ty::IntVar(_) => CanonicalVarKind::Ty(CanonicalTyVarKind::Int),
322-
ty::FloatVar(_) => CanonicalVarKind::Ty(CanonicalTyVarKind::Float),
316+
ty::IntVar(vid) => {
317+
assert_eq!(
318+
self.infcx.opportunistic_resolve_int_var(vid),
319+
t,
320+
"ty vid should have been resolved fully before canonicalization"
321+
);
322+
CanonicalVarKind::Ty(CanonicalTyVarKind::Int)
323+
}
324+
ty::FloatVar(vid) => {
325+
assert_eq!(
326+
self.infcx.opportunistic_resolve_float_var(vid),
327+
t,
328+
"ty vid should have been resolved fully before canonicalization"
329+
);
330+
CanonicalVarKind::Ty(CanonicalTyVarKind::Float)
331+
}
323332
ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
324-
todo!()
333+
panic!("fresh vars not expected in canonicalization")
325334
}
326335
},
327336
ty::Placeholder(placeholder) => match self.canonicalize_mode {
@@ -388,13 +397,8 @@ impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I>
388397
ty::ConstKind::Infer(i) => match i {
389398
ty::InferConst::Var(vid) => {
390399
assert_eq!(
391-
self.infcx.root_ct_var(vid),
392-
vid,
393-
"region vid should have been resolved fully before canonicalization"
394-
);
395-
assert_eq!(
396-
self.infcx.probe_ct_var(vid),
397-
None,
400+
self.infcx.opportunistic_resolve_ct_var(vid, ty),
401+
c,
398402
"region vid should have been resolved fully before canonicalization"
399403
);
400404
CanonicalVarKind::Const(self.infcx.universe_of_ct(vid).unwrap(), ty)
@@ -467,3 +471,82 @@ impl<I: Interner> TypeFolder<I> for RegionsToStatic<I> {
467471
}
468472
}
469473
}
474+
475+
///////////////////////////////////////////////////////////////////////////
476+
// EAGER RESOLUTION
477+
478+
/// Resolves ty, region, and const vars to their inferred values or their root vars.
479+
pub struct EagerResolver<
480+
'a,
481+
Infcx: InferCtxtLike<Interner = I>,
482+
I: Interner = <Infcx as InferCtxtLike>::Interner,
483+
> {
484+
infcx: &'a Infcx,
485+
}
486+
487+
impl<'a, Infcx: InferCtxtLike> EagerResolver<'a, Infcx> {
488+
pub fn new(infcx: &'a Infcx) -> Self {
489+
EagerResolver { infcx }
490+
}
491+
}
492+
493+
impl<Infcx: InferCtxtLike<Interner = I>, I: Interner> TypeFolder<I> for EagerResolver<'_, Infcx> {
494+
fn interner(&self) -> I {
495+
self.infcx.interner()
496+
}
497+
498+
fn fold_ty(&mut self, t: I::Ty) -> I::Ty {
499+
match t.kind() {
500+
ty::Infer(ty::TyVar(vid)) => {
501+
let resolved = self.infcx.opportunistic_resolve_ty_var(vid);
502+
if t != resolved && resolved.has_infer() {
503+
resolved.super_fold_with(self)
504+
} else {
505+
resolved
506+
}
507+
}
508+
ty::Infer(ty::IntVar(vid)) => self.infcx.opportunistic_resolve_int_var(vid),
509+
ty::Infer(ty::FloatVar(vid)) => self.infcx.opportunistic_resolve_float_var(vid),
510+
_ => {
511+
if t.has_infer() {
512+
t.super_fold_with(self)
513+
} else {
514+
t
515+
}
516+
}
517+
}
518+
}
519+
520+
fn fold_region(&mut self, r: I::Region) -> I::Region {
521+
match r.kind() {
522+
ty::ReVar(vid) => self.infcx.opportunistic_resolve_lt_var(vid),
523+
_ => r,
524+
}
525+
}
526+
527+
fn fold_const(&mut self, c: I::Const) -> I::Const {
528+
match c.kind() {
529+
ty::ConstKind::Infer(ty::InferConst::Var(vid)) => {
530+
let ty = c.ty().fold_with(self);
531+
let resolved = self.infcx.opportunistic_resolve_ct_var(vid, ty);
532+
if c != resolved && resolved.has_infer() {
533+
resolved.super_fold_with(self)
534+
} else {
535+
resolved
536+
}
537+
}
538+
ty::ConstKind::Infer(ty::InferConst::EffectVar(vid)) => {
539+
let bool = Ty::new_bool(self.infcx.interner());
540+
debug_assert_eq!(c.ty(), bool);
541+
self.infcx.opportunistic_resolve_effect_var(vid, bool)
542+
}
543+
_ => {
544+
if c.has_infer() {
545+
c.super_fold_with(self)
546+
} else {
547+
c
548+
}
549+
}
550+
}
551+
}
552+
}

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,6 @@ use rustc_index::IndexVec;
1818
use rustc_infer::infer::canonical::query_response::make_query_region_constraints;
1919
use rustc_infer::infer::canonical::CanonicalVarValues;
2020
use rustc_infer::infer::canonical::{CanonicalExt, QueryRegionConstraints};
21-
use rustc_infer::infer::resolve::EagerResolver;
2221
use rustc_infer::infer::RegionVariableOrigin;
2322
use rustc_infer::infer::{InferCtxt, InferOk};
2423
use rustc_infer::traits::solve::NestedNormalizationGoals;
@@ -30,6 +29,7 @@ use rustc_middle::traits::solve::{
3029
};
3130
use rustc_middle::traits::ObligationCause;
3231
use rustc_middle::ty::{self, BoundVar, GenericArgKind, Ty, TyCtxt, TypeFoldable};
32+
use rustc_next_trait_solver::canonicalizer::EagerResolver;
3333
use rustc_next_trait_solver::canonicalizer::{CanonicalizeMode, Canonicalizer};
3434
use rustc_span::{Span, DUMMY_SP};
3535
use std::assert_matches::assert_matches;

‎compiler/rustc_trait_selection/src/solve/inspect/analyse.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@
1111
1212
use rustc_ast_ir::try_visit;
1313
use rustc_ast_ir::visit::VisitorResult;
14-
use rustc_infer::infer::resolve::EagerResolver;
1514
use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, InferOk};
1615
use rustc_macros::extension;
1716
use rustc_middle::traits::query::NoSolution;
@@ -20,6 +19,7 @@ use rustc_middle::traits::solve::{Certainty, Goal};
2019
use rustc_middle::traits::ObligationCause;
2120
use rustc_middle::ty::{TyCtxt, TypeFoldable};
2221
use rustc_middle::{bug, ty};
22+
use rustc_next_trait_solver::canonicalizer::EagerResolver;
2323
use rustc_span::{Span, DUMMY_SP};
2424

2525
use crate::solve::eval_ctxt::canonical;

0 commit comments

Comments
 (0)