Clean up and speed up inference variable resolving code by jdonszelmann · Pull Request #160913 · rust-lang/rust

jdonszelmann · 2026-08-11T14:24:56Z

Clean up the resolve* family of functions in InferCtxt, renaming various functions to have more consistent and descriptive names. Adds a lot of documentation, and even wins some performance using the fact that shallow_resolve now returns root vids.

Reviewable commit by commit: some are large renames across the board, which are separated from the perf wins
and small renames in other commits to hopefully make more sense.

The functions are now called:

before	after	note
`shallow_resolve_*`	(unchanged) `shallow_resolve_*`	Now with newly added docs.
`resolve_vars_if_possible_*`	`deeply_resolve_ignoring_regions_*`	deliberately longer name, we want to encourage using `deeply_resolve` instead.
`eager_resolve_vars`	`deeply_resolve`
`fully_resolve`	(unchanged) `fully_resolve`	Resolves with regions and asserts that all variables are resolved at the end.
`opportunistic_resolve_var`		gone, same as `shalllow_resolve` now that we resolve to roots

Note

I've not used an LLM for any part of this PR, or any other PR I make. This includes any related work like research.

rustbot · 2026-08-11T14:25:00Z

changes to inspect_obligations.rs

cc @lcnr

changes to the core type system

cc @lcnr

Some changes occurred in need_type_info.rs

cc @lcnr

Some changes occurred to the core trait solver

cc @rust-lang/initiative-trait-system-refactor

changes to the core type system

cc @lcnr

jdonszelmann · 2026-08-11T14:25:09Z

@bors try @rust-timer queue

Clean up and speed up resolving code

jdonszelmann · 2026-08-11T14:53:08Z

-        match self.inner.borrow_mut().type_variables().probe(vid) {
-            TypeVariableValue::Known { value } => Ok(value),
+        match value {
+            TypeVariableValue::Known { value } => Ok(self.shallow_resolve_non_recursive(value)),


this method (and the one below) now also does the recursive resolving shallow_resolve already did. No tests change here.

View changes since the review

jdonszelmann · 2026-08-11T14:53:33Z

+    // Cold because the case in which a tyvar resolves to an intvar which resolves to a type is
+    // quite rare. It's way more common for `shallow_resolve_non_recursive` to return ty.
+    #[cold]
+    fn shallow_resolve_infer_non_recursive(&self, infer: InferTy, ty: Ty<'tcx>) -> Ty<'tcx> {


the non-recursive caase helps ~0.5% on local benchmarks. Not much, but still a bit.

View changes since the review

jdonszelmann · 2026-08-11T14:57:58Z

            }

            ty::Infer(ty::IntVar(vid)) => {
-                let nt = self.infcx.unwrap().opportunistic_resolve_int_var(vid);


renames all the opportunistic_* functions with simply shallow_resolve_*. I've done this in many places. I've added a lot of docs to all the resolve methods, which I think makes it super clear that resolving is always an opportunistic process that doesn't necessarily resolve all variables, simply because it can't always.

From the perspective of a new contributor, they'll see a resolve_* function for the first time, go to its docs, and learn that the purpose of all resolve_* methods is to opportunistically resolve variables.

Since the behavior is the same for all the resolve_* functions I think that will actually make things clearer than randomly calling some of them "opportunistic" even when the others are inherently also opportunistic.

View changes since the review

jdonszelmann · 2026-08-11T14:59:06Z

+    /// In cases where we do, this can aid performance.
    #[inline(always)]
-    fn shallow_resolve_ty_var(&self, v: TyVid, ty: Ty<'tcx>) -> Ty<'tcx> {
+    fn shallow_resolve_ty_var_with_ty(&self, v: TyVid, ty: Option<Ty<'tcx>>) -> Ty<'tcx> {


By taking an Option here, we can merge more methods' implementations. Doing this has 0 performance overhead, #[inline(always)] makes sure the callsites that always call with Some get optimized properly.

View changes since the review

could we instead change this function to not take a ty and return and Option instead?

rust-bors · 2026-08-11T15:25:32Z

💔 Test for 7e8d4ec failed: CI. Failed job:

try - dist-x86_64-linux-quick (web logs, enhanced plaintext logs)

jdonszelmann · 2026-08-11T15:47:37Z

@bors try (failed due to missing rustdoc changes now applied)

rust-bors · 2026-08-11T15:47:41Z

Unknown argument "(failed". Did you mean to use @bors jobs=<jobs>|parent=<parent>? Run @bors help or go to https://bors.rust-lang.org/help to see available commands.

panstromek · 2026-08-11T16:49:37Z

@bors try

Clean up and speed up resolving code

rust-bors · 2026-08-11T17:49:20Z

☀️ Try build successful (CI)
Build commit: d881e22 (d881e228b79422918a125ef8385170091369309b)
Base parent: a04c7a0 (a04c7a037d59b6dedc9f921e84e391f13a257aa4)

jdonszelmann · 2026-08-12T08:06:52Z

@rustbot review

lcnr · 2026-08-12T09:46:48Z

-                Ty::new_int_var(self.tcx, inner.int_unification_table().find(vid))
-            }
-        }
+    pub fn shallow_resolve_int_var(&self, vid: ty::IntVid) -> Ty<'tcx> {


if we return None if the inner function doesn't make progress, could we always be explicit about reconstructing the type in the caller to make it explicit where we (likely unnecessarily) do so?

View changes since the review

lcnr · 2026-08-12T09:47:29Z

                .borrow_mut()
                .unwrap_region_constraints()
-                .opportunistic_resolve_var(canonicalizer.tcx, vid);
+                .shallow_resolve_region_var(canonicalizer.tcx, vid);


we don't reuse r here if the root doesn't change 🤔 feels like doing so would be good for perf 🤔

View changes since the review

lcnr · 2026-08-12T09:52:06Z

so we have the following now

shallow_resolve_X now
deep_resolve_non_region_vars
eagerly_resolve_vars deep resolve which does resolve region vars
fully_resolve deep resolve which uses the region graph instead of only the unification tables

jdonszelmann · 2026-08-21T09:20:43Z

The functions are now called:

before	after	note
`shallow_resolve_*`	(unchanged) `shallow_resolve_*`	Now with newly added docs.
`resolve_vars_if_possible_*`	`deeply_resolve_ignoring_regions_*`	deliberately longer name, we want to encourage using `deeply_resolve` instead.
`eager_resolve_vars`	`deeply_resolve`
`fully_resolve`	(unchanged) `fully_resolve`	Resolves with regions and asserts that all variables are resolved at the end.
`opportunistic_resolve_var`		gone, same as `shalllow_resolve` now that we resolve to roots

… tyvar.

…er a shallow_resolve

rustbot · 2026-08-24T08:11:52Z

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

lcnr

reviewed most of the files.

can you split this PR into multiple separate ones. Reviewing that many changes in this PR feels kind of iffy

View changes since this review

lcnr · 2026-08-24T16:03:53Z

+                        .filter(|t| {
+                            !self.deeply_resolve_ignoring_regions_with_obligations(*t).is_ty_var()
+                        })


for separate PR: this call to deeply_resolve_ignoring_regions_with_obligations is redundant

lcnr · 2026-08-24T16:11:50Z

            .only_has_type(self)
-            .and_then(|ty| self.resolve_vars_with_obligations(ty).opt_tuple_fields())
+            .and_then(|ty| {
+                self.deeply_resolve_ignoring_regions_with_obligations(ty).opt_tuple_fields()


for separate PR: this call to deeply_resolve_ignoring_regions_with_obligations is redundant

lcnr · 2026-08-24T16:12:26Z

                    return Err(TypeError::Mismatch);
                }
-                Ok(self.resolve_vars_if_possible(adt_ty))
+                Ok(self.deeply_resolve_ignoring_regions(adt_ty))


for separate PR: this call to deeply_resolve_ignoring_regions_with_obligations is redundant

lcnr · 2026-08-24T16:19:26Z

                    let mut pat_ref_layers = 0;
                    while let ty::Ref(_, inner_ty, mutbl) =
-                        *self.resolve_vars_with_obligations(peeled_ty).kind()
+                        *self.deeply_resolve_ignoring_regions_with_obligations(peeled_ty).kind()


for separate PR: this call is redundant

lcnr · 2026-08-24T16:26:41Z

                // region vids before processing regions, so we have a better chance to match clauses
                // in our param-env.
-                let (sup_type, sub_region) = eager_resolve_vars(self, (sup_type, sub_region));
+                let (sup_type, sub_region) = deeply_resolve(self, (sup_type, sub_region));


can you make this a method on the InferCtxt 🤔 we should push people to use that instead of deeply_resolve_ignoring_regions :>

lcnr · 2026-08-24T16:27:41Z

        &mut self,
        tcx: TyCtxt<'tcx>,
        vid: ty::RegionVid,
    ) -> ty::Region<'tcx> {


also separate: I feel like shallow_resolve_X should return Option and None if the vid doesn't change 🤔

there are a bunch of callers which shouldn't rebuild the ty/region here

lcnr · 2026-08-24T16:28:37Z

-            Err(_) => Ty::new_var(self.tcx, self.root_var(vid)),
-        }
+    fn shallow_resolve_ty_var(&self, vid: ty::TyVid) -> Ty<'tcx> {
+        self.shallow_resolve_ty_var_with_ty(vid, None)


I dislike this function. Imo we should instead have shallow_resolve_ty_var_with_ty return Option<Ty> and then do the unwrap_or(ty) in the caller

lcnr · 2026-08-24T16:31:30Z

+    /// Resolve a type variable to a type, if known.
+    /// Otherwise return a type with the root vid in it.
+    #[inline(always)]
+    fn shallow_resolve_ty_var_with_ty(&self, v: TyVid, ty: Option<Ty<'tcx>>) -> Ty<'tcx> {


yeah, with_ty is :<

lcnr · 2026-08-24T16:32:15Z

 }

-impl<'a, 'tcx> OpportunisticVarResolver<'a, 'tcx> {
+impl<'a, 'tcx> DeepResolverIgnoringRegions<'a, 'tcx> {


maybe just actually call that struct DeeplyResolveIgnoringRegions. DeepResolver sounds odd

lcnr · 2026-08-24T16:35:41Z

there are renames and behavior changes here. And I'd like to either first do behavior changes and then renames, or the other way round. but having something that has merge conflicts because it touches a bunch of files while also having subtle changes to the core of infer var handling is :/

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. WG-trait-system-refactor The Rustc Trait System Refactor Initiative (-Znext-solver) labels Aug 11, 2026

rustbot assigned lcnr Aug 11, 2026

This comment has been minimized.

Sign in to view

rustbot added the S-waiting-on-perf Status: Waiting on a perf run to be completed. label Aug 11, 2026

This comment has been minimized.

Sign in to view

rust-bors Bot pushed a commit that referenced this pull request Aug 11, 2026

Auto merge of #160913 - jdonszelmann:cleanup-resolving, r=<try>

7e8d4ec

Clean up and speed up resolving code

This comment has been minimized.

Sign in to view

jdonszelmann force-pushed the cleanup-resolving branch from 3dde145 to b5fe24d Compare August 11, 2026 14:45

This comment has been minimized.

Sign in to view

jdonszelmann commented Aug 11, 2026

View reviewed changes

rust-bors Bot added S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Aug 11, 2026

This comment has been minimized.

Sign in to view

jdonszelmann force-pushed the cleanup-resolving branch from b5fe24d to 6b88c26 Compare August 11, 2026 15:47

rustbot added the T-rustdoc-frontend Relevant to the rustdoc-frontend team, which will review and decide on the web UI/UX output. label Aug 11, 2026

This comment has been minimized.

Sign in to view

rust-bors Bot pushed a commit that referenced this pull request Aug 11, 2026

Auto merge of #160913 - jdonszelmann:cleanup-resolving, r=<try>

d881e22

Clean up and speed up resolving code

jdonszelmann force-pushed the cleanup-resolving branch from 6b88c26 to 06dd748 Compare August 12, 2026 08:04

This comment has been minimized.

Sign in to view

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. and removed S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. labels Aug 12, 2026

lcnr changed the title ~~Clean up and speed up resolving code~~ Clean up and speed up inference variable resolving code Aug 12, 2026

lcnr reviewed Aug 12, 2026

View reviewed changes

Comment thread compiler/rustc_infer/src/infer/mod.rs Outdated

lcnr reviewed Aug 12, 2026

View reviewed changes

Comment thread compiler/rustc_infer/src/infer/mod.rs

lcnr reviewed Aug 12, 2026

View reviewed changes

This comment has been minimized.

Sign in to view

jdonszelmann mentioned this pull request Aug 18, 2026

Optimize probing in shallow_resolve #160885

Open

jdonszelmann force-pushed the cleanup-resolving branch from 06dd748 to 9ddd601 Compare August 21, 2026 09:15

This comment has been minimized.

Sign in to view

jdonszelmann force-pushed the cleanup-resolving branch from 9ddd601 to 68fded2 Compare August 21, 2026 09:17

This comment has been minimized.

Sign in to view

jdonszelmann added 8 commits August 24, 2026 09:53

optimize resolve, and properly document the related methods

c052e87

unify implementations of shallow_resolve and opportunistic_resolve

18a6a7d

Make region methods consistent and faster.

b03932c

Make const methods consistent and expose methods to shallow resolve a…

c87dc5f

… tyvar.

expose the same through inferctxlike

e51f72e

rename resolver folders and their access functions

08e226d

make lifetime methods more consistent

e1878cd

fixup various sites that use root_{ty,const}_var that can skip it aft…

aad9f36

…er a shallow_resolve

jdonszelmann force-pushed the cleanup-resolving branch from 68fded2 to aad9f36 Compare August 24, 2026 08:11

lcnr reviewed Aug 24, 2026

View reviewed changes

Uh oh!

Uh oh!

Conversation

jdonszelmann commented Aug 11, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

rustbot commented Aug 11, 2026

Uh oh!

jdonszelmann commented Aug 11, 2026

Uh oh!

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

This comment has been minimized.

jdonszelmann Aug 11, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jdonszelmann Aug 11, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jdonszelmann Aug 11, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jdonszelmann Aug 11, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

This comment has been minimized.

rust-bors Bot commented Aug 11, 2026

Uh oh!

jdonszelmann commented Aug 11, 2026

Uh oh!

rust-bors Bot commented Aug 11, 2026

Uh oh!

This comment has been minimized.

panstromek commented Aug 11, 2026

Uh oh!

This comment has been minimized.

rust-bors Bot commented Aug 11, 2026

Uh oh!

This comment has been minimized.

jdonszelmann commented Aug 12, 2026

Uh oh!

Uh oh!

Uh oh!

lcnr Aug 12, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lcnr Aug 12, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

lcnr commented Aug 12, 2026

Uh oh!

This comment has been minimized.

This comment has been minimized.

jdonszelmann commented Aug 21, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

This comment has been minimized.

rustbot commented Aug 24, 2026

Uh oh!

lcnr left a comment • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jdonszelmann commented Aug 11, 2026 •

edited

Loading

jdonszelmann Aug 11, 2026 •

edited by rustbot

Loading

jdonszelmann Aug 11, 2026 •

edited by rustbot

Loading

jdonszelmann Aug 11, 2026 •

edited by rustbot

Loading

jdonszelmann Aug 11, 2026 •

edited by rustbot

Loading

lcnr Aug 12, 2026 •

edited by rustbot

Loading

lcnr Aug 12, 2026 •

edited by rustbot

Loading

jdonszelmann commented Aug 21, 2026 •

edited

Loading

lcnr left a comment •

edited by rustbot

Loading