Skip to content

Clean up and speed up inference variable resolving code #160913

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
jdonszelmann wants to merge 6 commits into
base: main
Choose a base branch
from
+751 −561
Open

Clean up and speed up inference variable resolving code #160913

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
ab88cbc
rename resolver folders and their access functions
jdonszelmann Aug 11, 2026
e7c7eb0
rename opportunistic_resolve to shallow_resolve
jdonszelmann Aug 11, 2026
9b7df05
optimize resolve, and properly document the related methods
jdonszelmann Aug 11, 2026
84075ba
use probe_key_value for shallow_resolve_region
jdonszelmann Aug 11, 2026
575ba3a
Make const methods consistent and expose methods to shallow resolve a…
jdonszelmann Aug 11, 2026
25e4653
fixup various sites that use root_{ty,const}_var that can skip it aft…
jdonszelmann Aug 11, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion compiler/rustc_borrowck/src/diagnostics/region_errors.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -955,7 +955,7 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
tcx,
self.infcx.typing_env(self.infcx.param_env),
fn_did,
self.infcx.resolve_vars_if_possible(args.no_bound_vars().unwrap()),
self.infcx.deeply_resolve_ignoring_regions(args.no_bound_vars().unwrap()),
) else {
return;
};
Expand Down
2 changes: 1 addition & 1 deletion compiler/rustc_borrowck/src/region_infer/opaque_types/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -73,7 +73,7 @@ pub(crate) fn clone_and_resolve_opaque_types<'tcx>(
let opaque_types = opaque_types
.into_iter()
.map(|entry| {
fold_regions(infcx.tcx, infcx.resolve_vars_if_possible(entry), |r, _| {
fold_regions(infcx.tcx, infcx.deeply_resolve_ignoring_regions(entry), |r, _| {
let vid = if let ty::RePlaceholder(placeholder) = r.kind() {
constraints.placeholder_region(infcx, placeholder).as_var()
} else {
Expand Down
2 changes: 1 addition & 1 deletion compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -158,7 +158,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {

GenericArgKind::Type(mut t1) => {
// Scraped constraints may have had inference vars.
t1 = self.infcx.resolve_vars_if_possible(t1);
t1 = self.infcx.deeply_resolve_ignoring_regions(t1);

let implicit_region_bound =
ty::Region::new_var(tcx, universal_regions.implicit_region_bound());
Expand Down
2 changes: 1 addition & 1 deletion compiler/rustc_borrowck/src/type_check/relate_tys.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -145,7 +145,7 @@ impl<'a, 'b, 'tcx> NllTypeRelating<'a, 'b, 'tcx> {
ty,
)?;
let new_var =
infcx.resolve_vars_if_possible(Ty::new_infer(infcx.tcx, ty::TyVar(ty_vid)));
infcx.deeply_resolve_ignoring_regions(Ty::new_infer(infcx.tcx, ty::TyVar(ty_vid)));

// Any regions in this new type must be live everywhere, so we mark them as such.
// (It may be that it only needs to be live where the opaque type itself is - which
Expand Down
6 changes: 3 additions & 3 deletions compiler/rustc_hir_analysis/src/autoderef.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -86,7 +86,7 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
// and Deref, and this has benefits for const and the emitted MIR.
let (kind, new_ty) =
if let Some(ty) = self.state.cur_ty.builtin_deref(self.include_raw_pointers) {
debug_assert_eq!(ty, self.infcx.resolve_vars_if_possible(ty));
debug_assert_eq!(ty, self.infcx.deeply_resolve_ignoring_regions(ty));
(AutoderefKind::Builtin, ty)
} else if let Some(ty) = self.overloaded_deref_ty(self.state.cur_ty) {
// The overloaded deref check already normalizes the pointee type.
Expand Down Expand Up @@ -123,7 +123,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
param_env,
state: AutoderefSnapshot {
steps: vec![],
cur_ty: infcx.resolve_vars_if_possible(base_ty),
cur_ty: infcx.deeply_resolve_ignoring_regions(base_ty),
obligations: PredicateObligations::new(),
at_start: true,
reached_recursion_limit: false,
Expand Down Expand Up @@ -171,7 +171,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);
self.state.obligations.extend(obligations);

Some(self.infcx.resolve_vars_if_possible(normalized_ty))
Some(self.infcx.deeply_resolve_ignoring_regions(normalized_ty))
}

#[instrument(level = "debug", skip(self), ret)]
Expand Down
8 changes: 4 additions & 4 deletions compiler/rustc_hir_analysis/src/check/check.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -427,8 +427,8 @@ fn check_opaque_meets_bounds<'tcx>(
} else {
// Check that any hidden types found during wf checking match the hidden types that `type_of` sees.
for (mut key, mut ty) in infcx.take_opaque_types() {
ty.ty = infcx.resolve_vars_if_possible(ty.ty);
key = infcx.resolve_vars_if_possible(key);
ty.ty = infcx.deeply_resolve_ignoring_regions(ty.ty);
key = infcx.deeply_resolve_ignoring_regions(key);
sanity_check_found_hidden_type(tcx, key, ty)?;
}
Ok(())
Expand Down Expand Up @@ -2317,8 +2317,8 @@ pub(super) fn check_coroutine_obligations(
// Check that any hidden types found when checking these stalled coroutine obligations
// are valid.
for (key, ty) in infcx.take_opaque_types() {
let hidden_type = infcx.resolve_vars_if_possible(ty);
let key = infcx.resolve_vars_if_possible(key);
let hidden_type = infcx.deeply_resolve_ignoring_regions(ty);
let key = infcx.deeply_resolve_ignoring_regions(key);
sanity_check_found_hidden_type(tcx, key, hidden_type)?;
}
} else {
Expand Down
8 changes: 4 additions & 4 deletions compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -584,9 +584,9 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
.iter()
.map(|(_, &(ty, _))| {
assert!(
infcx.resolve_vars_if_possible(ty) == ty && ty.is_ty_var(),
infcx.deeply_resolve_ignoring_regions(ty) == ty && ty.is_ty_var(),
"{ty:?} should not have been constrained via normalization",
ty = infcx.resolve_vars_if_possible(ty)
ty = infcx.deeply_resolve_ignoring_regions(ty)
);
idx += 1;
(
Expand Down Expand Up @@ -1296,7 +1296,7 @@ fn check_region_late_boundedness<'tcx>(
.inner
.borrow_mut()
.unwrap_region_constraints()
.opportunistic_resolve_var(tcx, vid)
.shallow_resolve_region_var(tcx, vid)
&& let ty::ReLateParam(ty::LateParamRegion {
kind: ty::LateParamRegionKind::Named(trait_param_def_id),
..
Expand All @@ -1321,7 +1321,7 @@ fn check_region_late_boundedness<'tcx>(
.inner
.borrow_mut()
.unwrap_region_constraints()
.opportunistic_resolve_var(tcx, vid)
.shallow_resolve_region_var(tcx, vid)
&& let ty::ReLateParam(ty::LateParamRegion {
kind: ty::LateParamRegionKind::Named(impl_param_def_id),
..
Expand Down
4 changes: 2 additions & 2 deletions compiler/rustc_hir_analysis/src/coherence/orphan.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -333,7 +333,7 @@ fn orphan_check<'tcx>(

let ocx = traits::ObligationCtxt::new(&infcx);
let ty = ocx.normalize(&cause, ty::ParamEnv::empty(), Unnormalized::new_wip(user_ty));
let ty = infcx.resolve_vars_if_possible(ty);
let ty = infcx.deeply_resolve_ignoring_regions(ty);
let errors = ocx.try_evaluate_obligations();
if !errors.no_errors() {
return Ok(user_ty);
Expand Down Expand Up @@ -377,7 +377,7 @@ fn orphan_check<'tcx>(
id_arg,
);
}
infcx.resolve_vars_if_possible(tys)
infcx.deeply_resolve_ignoring_regions(tys)
});
OrphanCheckErr::NonLocalInputType(tys)
}
Expand Down
4 changes: 2 additions & 2 deletions compiler/rustc_hir_analysis/src/collect.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1513,11 +1513,11 @@ pub fn suggest_impl_trait<'tcx>(
);
// FIXME(compiler-errors): We may benefit from resolving regions here.
if ocx.try_evaluate_obligations().no_errors()
&& let item_ty = infcx.resolve_vars_if_possible(item_ty)
&& let item_ty = infcx.deeply_resolve_ignoring_regions(item_ty)
&& let Some(item_ty) = item_ty.make_suggestable(infcx.tcx, false, None)
&& let Some(sugg) = formatter(
infcx.tcx,
infcx.resolve_vars_if_possible(args),
infcx.deeply_resolve_ignoring_regions(args),
trait_def_id,
assoc_item_def_id,
item_ty,
Expand Down
11 changes: 6 additions & 5 deletions compiler/rustc_hir_typeck/src/callee.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -103,7 +103,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
_ => self.check_expr(callee_expr),
};

let expr_ty = self.resolve_vars_with_obligations(original_callee_ty);
let expr_ty = self.deeply_resolve_ignoring_regions_with_obligations(original_callee_ty);

let mut autoderef = self.autoderef(callee_expr.span, expr_ty);
let mut result = None;
Expand Down Expand Up @@ -237,7 +237,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
arg_exprs: &'tcx [hir::Expr<'tcx>],
autoderef: &Autoderef<'a, 'tcx>,
) -> Option<CallStep<'tcx>> {
let adjusted_ty = self.resolve_vars_with_obligations(autoderef.final_ty());
let adjusted_ty =
self.deeply_resolve_ignoring_regions_with_obligations(autoderef.final_ty());

// If the callee is a function pointer or a closure, then we're all set.
match *adjusted_ty.kind() {
Expand Down Expand Up @@ -736,7 +737,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
return do_check();
}

resolved_inputs = self.resolve_vars_if_possible(formal_input_tys.to_vec());
resolved_inputs = self.deeply_resolve_ignoring_regions(formal_input_tys.to_vec());
}

// Fool typechecker by placing an adjusted type of the first arg to avoid errors.
Expand Down Expand Up @@ -873,7 +874,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
(rest_span, format!(").{}({rest_snippet}", segment.ident)),
]
};
let self_ty = self.resolve_vars_if_possible(pick.callee.sig.inputs()[0]);
let self_ty = self.deeply_resolve_ignoring_regions(pick.callee.sig.inputs()[0]);
diag.multipart_suggestion(
format!(
"use the `.` operator to call the method `{}{}` on `{self_ty}`",
Expand Down Expand Up @@ -925,7 +926,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(self, qpath)));
}

let callee_ty = self.resolve_vars_if_possible(callee_ty);
let callee_ty = self.deeply_resolve_ignoring_regions(callee_ty);
let mut path = None;
let mut err = self.dcx().create_err(diagnostics::InvalidCallee {
span: callee_expr.span,
Expand Down
44 changes: 22 additions & 22 deletions compiler/rustc_hir_typeck/src/cast.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -96,14 +96,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
) -> Result<Option<PointerKind<'tcx>>, ErrorGuaranteed> {
debug!("pointer_kind({:?}, {:?})", t, span);

let t = self.resolve_vars_if_possible(t);
let t = self.deeply_resolve_ignoring_regions(t);
t.error_reported()?;

if self.type_is_sized_modulo_regions(self.param_env, t) {
return Ok(Some(PointerKind::Thin));
}

let t = self.resolve_vars_with_obligations(t);
let t = self.deeply_resolve_ignoring_regions_with_obligations(t);

Ok(match *t.kind() {
ty::Slice(_) | ty::Str => Some(PointerKind::Length),
Expand Down Expand Up @@ -396,7 +396,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
err.emit();
}
CastError::CastToBool => {
let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
let expr_ty = fcx.deeply_resolve_ignoring_regions(self.expr_ty);
let help = if self.expr_ty.is_numeric() {
diagnostics::CannotCastToBoolHelp::Numeric(
self.expr_span.shrink_to_hi().with_hi(self.span.hi()),
Expand Down Expand Up @@ -539,8 +539,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
) {
// Check `impl From<self.expr_ty> for self.cast_ty {}` for accurate suggestion:
if let Some(from_trait) = fcx.tcx.get_diagnostic_item(sym::From) {
let ty = fcx.resolve_vars_if_possible(self.cast_ty);
let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
let ty = fcx.deeply_resolve_ignoring_regions(self.cast_ty);
let expr_ty = fcx.deeply_resolve_ignoring_regions(self.expr_ty);
if fcx
.infcx
.type_implements_trait(from_trait, [ty, expr_ty], fcx.param_env)
Expand Down Expand Up @@ -604,8 +604,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
err.emit();
}
CastError::SizedUnsizedCast => {
let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
let cast_ty = fcx.deeply_resolve_ignoring_regions(self.cast_ty);
let expr_ty = fcx.deeply_resolve_ignoring_regions(self.expr_ty);
fcx.dcx().emit_err(diagnostics::CastThinPointerToWidePointer {
span: self.span,
expr_ty,
Expand All @@ -615,8 +615,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
}
CastError::IntToWideCast(known_metadata) => {
let expr_if_nightly = fcx.tcx.sess.is_nightly_build().then_some(self.expr_span);
let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
let cast_ty = fcx.deeply_resolve_ignoring_regions(self.cast_ty);
let expr_ty = fcx.deeply_resolve_ignoring_regions(self.expr_ty);
let metadata = known_metadata.unwrap_or("type-specific metadata");
let known_wide = known_metadata.is_some();
let span = self.cast_span;
Expand Down Expand Up @@ -659,8 +659,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
});
}
CastError::CastEnumDrop => {
let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
let expr_ty = fcx.deeply_resolve_ignoring_regions(self.expr_ty);
let cast_ty = fcx.deeply_resolve_ignoring_regions(self.cast_ty);

fcx.dcx().emit_err(diagnostics::CastEnumDrop { span: self.span, expr_ty, cast_ty });
}
Expand Down Expand Up @@ -707,7 +707,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
self.expr_ty,
E0620,
"cast to unsized type: `{}` as `{}`",
fcx.resolve_vars_if_possible(self.expr_ty),
fcx.deeply_resolve_ignoring_regions(self.expr_ty),
tstr
);
match self.expr_ty.kind() {
Expand Down Expand Up @@ -747,8 +747,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
} else {
(false, TRIVIAL_CASTS)
};
let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
let expr_ty = fcx.deeply_resolve_ignoring_regions(self.expr_ty);
let cast_ty = fcx.deeply_resolve_ignoring_regions(self.cast_ty);
fcx.tcx.emit_node_span_lint(
lint,
self.expr.hir_id,
Expand Down Expand Up @@ -788,8 +788,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {

fn expr_span_for_type_resolution(&self, fcx: &FnCtxt<'a, 'tcx>) -> Span {
if let hir::ExprKind::Index(_, idx, _) = self.expr.kind
&& fcx.resolve_vars_if_possible(self.expr_ty).is_ty_var()
&& fcx.resolve_vars_if_possible(fcx.node_ty(idx.hir_id)).is_ty_var()
&& fcx.deeply_resolve_ignoring_regions(self.expr_ty).is_ty_var()
&& fcx.deeply_resolve_ignoring_regions(fcx.node_ty(idx.hir_id)).is_ty_var()
{
index_operand_ambiguity_span(idx)
} else {
Expand All @@ -801,7 +801,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
pub(crate) fn check(mut self, fcx: &FnCtxt<'a, 'tcx>) {
let expr_span = self.expr_span_for_type_resolution(fcx);
self.expr_ty = fcx.structurally_resolve_type(expr_span, self.expr_ty);
self.cast_ty = fcx.resolve_vars_with_obligations(self.cast_ty);
self.cast_ty = fcx.deeply_resolve_ignoring_regions_with_obligations(self.cast_ty);
if self.cast_ty.is_ty_var() {
self.cast_ty = if let Some(guar) = self.try_report_ambiguous_binop_for_infer_cast(fcx) {
let err = Ty::new_error(fcx.tcx, guar);
Expand Down Expand Up @@ -863,7 +863,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
.pending_obligations()
.into_iter()
.filter_map(|mut obligation| {
let predicate = fcx.resolve_vars_if_possible(obligation.predicate);
let predicate = fcx.deeply_resolve_ignoring_regions(obligation.predicate);
if !matches!(
predicate.kind().skip_binder(),
ty::PredicateKind::Clause(ty::ClauseKind::Trait(_))
Expand All @@ -877,8 +877,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
else {
return None;
};
let lhs_ty = fcx.resolve_vars_if_possible(fcx.node_ty(*lhs_hir_id));
let rhs_ty = fcx.resolve_vars_if_possible(fcx.node_ty(*rhs_hir_id));
let lhs_ty = fcx.deeply_resolve_ignoring_regions(fcx.node_ty(*lhs_hir_id));
let rhs_ty = fcx.deeply_resolve_ignoring_regions(fcx.node_ty(*rhs_hir_id));

if (fcx.tcx.hir_span(*lhs_hir_id).contains(cast_span)
&& lhs_ty.contains(self.cast_ty))
Expand Down Expand Up @@ -1203,8 +1203,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
mut m_cast: ty::TypeAndMut<'tcx>,
) -> Result<CastKind, CastError<'tcx>> {
// array-ptr-cast: allow mut-to-mut, mut-to-const, const-to-const
m_expr.ty = fcx.resolve_vars_with_obligations(m_expr.ty);
m_cast.ty = fcx.resolve_vars_with_obligations(m_cast.ty);
m_expr.ty = fcx.deeply_resolve_ignoring_regions_with_obligations(m_expr.ty);
m_cast.ty = fcx.deeply_resolve_ignoring_regions_with_obligations(m_cast.ty);

if m_expr.mutbl >= m_cast.mutbl
&& let ty::Array(ety, _) = m_expr.ty.kind()
Expand Down
Loading
Loading