This PR implements a prototype of TY-aware delayed HIR lowering. Part of #118212.

r? @petrochenkov

Motivation

When lowering delegation in perfect scenario we would like to access the TY-level information, in particular, queries like generics_of, type_of, fn_sig for proper HIR generation with less hacks. For example, we do not want to generate more lifetimes than needed, because without TY-level queries we do not know which delegee's lifetimes are late-bound. Next, consider recursive delegations, for their proper support without TY we would have to either duplicate generics inheritance code in AST -> HIR lowering or create stubs for parts of the HIR and materialize them later. We already use those queries when interacting with external crates, however when dealing with compilation of a local crate we should use resolver for similar purposes. Finally, access to TY-level queries is expected to help supporting delegation to inherent impls, as we can not resolve such calls during AST -> HIR stage.

Benefits

We eliminate almost all code that uses resolver in delegation lowering:

• Attributes inheritance is done without copying attributes from AST at resolve stage
• Fn signatures are obtained from tcx.fn_sig
• Param counts are also obtained from tcx.fn_sig
• is_method function now uses tcx.associated_item instead of resolver
• Generics are now inherited through get_external_generics that uses tcx.generics_of. Generics for recursive delegations should also work
• DelegationIds that stored paths for recursive delegations is removed, we now use only delegee_id
• Structs that were used for storing delegation-related information in resolver are almost fully removed
• ast_index is no more used

Next steps

• Remove creating generic params through AST cloning, proper const types propagation
• Inherent impls

High level design overview

Queries

We store ids of delayed items to lower in Crate struct. During first stage of lowering, owners that correspond to delayed items are filled with MaybeOwner::Phantom.

Next, we define two new queries: lower_to_hir_delayed and get_delayed_child_owner.

The first query is used when lowering known delayed owner.

The second is feeded with children that were obtained during lowering of a delayed owner (note that the result of lowering of a single LocalDefId is not a single MaybeOwner, its a list of (LocalDefId, MaybeOwner) where the first MaybeOwner corresponds to delayed LocalDefId and others to children that were obtained during lowering (i.e. generic params)). By default get_delayed_child_owner returns MaybeOwner::Phantom. As we do not want to predict the whole list of children which will be obtained after lowering of a single delayed item, we need to store those children somewhere. There are several options:

• Make the return type of lower_to_hir_delayed to be FxIndexMap<LocalDefId, MaybeOwner> and search children here. Search will be either linear or we can introduce a map somewhere which will track parent-child relations between a single delayed LocalDefId and its children.
• Try to make query that will lower all delayed items in a loop and return a complete map of all delayed LocalDefIds and their children. In this case there will be problems with delayed items that require information about other delayed items.

By using such atomic queries we handle the second concern, and in case of acyclic dependencies between delayed ids it automatically works, moreover we use queries as cache for delayed MaybeOwners. The only invariant here is that queries which are invoked during delayed HIR lowering of some LocalDefId should not in any way access children of other, yet unlowered, delayed LocalDefId, they should firstly materialize it.

Resolver for lowering

Currently the resolver_for_lowering is stolen in lower_to_hir function, however we want to prolong its life until all delayed LocalDefIds are materialized. For this purpose we borrow resolver_for_lowering in lower_to_hir and drop it after forcing materialization of all delayed LocalDefId in rustc_interface::run_required_analyses.

We also split resolver for lowering into two parts: the first part is a readonly part that came to us from resolve, the second part is a mutable part that can be used to add or overwrite values in the readonly part. Now we modify resolver in place as we steal it, however in this PR we borrow it so we need to split it.

AST index

Lowering uses an AST index. It is created in lower_to_hir function and it references parts of AST. We want to avoid reindexing AST on every delayed LocalDefId lowering, however now it is not clear how to properly do it. As delayed HIR lowering is used only for delegation unstable feature it should not affect other use-cases of the compiler. But it will be reworked sooner or later.