Steal ResolverAstLowering when indexing AST.

Author: cjgillot

compiler/rustc_ast_lowering/src/asm.rs

@@ -21,7 +21,7 @@ use crate::{
     AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
 };
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(crate) fn lower_inline_asm(
         &mut self,
         sp: Span,

compiler/rustc_ast_lowering/src/block.rs

@@ -6,7 +6,7 @@ use smallvec::SmallVec;
 
 use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_block(
         &mut self,
         b: &Block,

compiler/rustc_ast_lowering/src/contract.rs

@@ -4,7 +4,7 @@ use thin_vec::thin_vec;
 
 use crate::LoweringContext;
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     /// Lowered contracts are guarded with the `contract_checks` compiler flag,
     /// i.e. the flag turns into a boolean guard in the lowered HIR. The reason
     /// for not eliminating the contract code entirely when the `contract_checks`

compiler/rustc_ast_lowering/src/delegation.rs

@@ -120,7 +120,7 @@ static ATTRS_ADDITIONS: &[AttrAdditionInfo] = &[
     },
 ];
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
             DefKind::Fn => false,
@@ -748,13 +748,13 @@ impl<'hir> LoweringContext<'hir> {
     }
 }
 
-struct SelfResolver<'a, 'hir> {
-    ctxt: &'a mut LoweringContext<'hir>,
+struct SelfResolver<'a, 'b, 'hir> {
+    ctxt: &'a mut LoweringContext<'b, 'hir>,
     path_id: NodeId,
     self_param_id: NodeId,
 }
 
-impl SelfResolver<'_, '_> {
+impl SelfResolver<'_, '_, '_> {
     fn try_replace_id(&mut self, id: NodeId) {
         if let Some(res) = self.ctxt.get_partial_res(id)
             && let Some(Res::Local(sig_id)) = res.full_res()
@@ -765,7 +765,7 @@ impl SelfResolver<'_, '_> {
     }
 }
 
-impl<'ast> Visitor<'ast> for SelfResolver<'_, '_> {
+impl<'ast> Visitor<'ast> for SelfResolver<'_, '_, '_> {
     fn visit_id(&mut self, id: NodeId) {
         self.try_replace_id(id);
     }

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -114,7 +114,7 @@ impl DelegationGenericsKind {
 impl<'hir> HirOrTyGenerics<'hir> {
     pub(super) fn into_hir_generics(
         &mut self,
-        ctx: &mut LoweringContext<'hir>,
+        ctx: &mut LoweringContext<'_, 'hir>,
         span: Span,
     ) -> &mut HirOrTyGenerics<'hir> {
         if let HirOrTyGenerics::Ty(ty) = self {
@@ -140,7 +140,7 @@ impl<'hir> HirOrTyGenerics<'hir> {
 
     pub(super) fn into_generic_args(
         &self,
-        ctx: &mut LoweringContext<'hir>,
+        ctx: &mut LoweringContext<'_, 'hir>,
         span: Span,
     ) -> &'hir hir::GenericArgs<'hir> {
         match self {
@@ -203,7 +203,7 @@ impl<'hir> GenericsGenerationResults<'hir> {
     }
 }
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn uplift_delegation_generics(
         &mut self,
         delegation: &Delegation,

compiler/rustc_ast_lowering/src/expr.rs

@@ -115,7 +115,7 @@ impl<'v> rustc_ast::visit::Visitor<'v> for WillCreateDefIdsVisitor {
     }
 }
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     fn with_move_expr_bindings<T>(
         &mut self,
         state: Option<MoveExprState<'hir>>,
@@ -1171,7 +1171,7 @@ impl<'hir> LoweringContext<'hir> {
         whole_span: Span,
     ) -> hir::ExprKind<'hir> {
         // Return early in case of an ordinary assignment.
-        fn is_ordinary(lower_ctx: &mut LoweringContext<'_>, lhs: &Expr) -> bool {
+        fn is_ordinary(lower_ctx: &mut LoweringContext<'_, '_>, lhs: &Expr) -> bool {
             match &lhs.kind {
                 ExprKind::Array(..)
                 | ExprKind::Struct(..)

compiler/rustc_ast_lowering/src/expr/closure.rs

@@ -9,7 +9,7 @@ use super::{LoweringContext, MoveExprInitializerFinder, MoveExprState};
 use crate::FnDeclKind;
 use crate::diagnostics::{ClosureCannotBeStatic, CoroutineTooManyParameters};
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     // Entry point for `ExprKind::Closure`. Plain closures go through
     // `lower_expr_plain_closure_with_move_exprs`, which can wrap the lowered
     // closure in `let` initializers for `move(...)`. Coroutine closures keep the

compiler/rustc_ast_lowering/src/format.rs

@@ -8,7 +8,7 @@ use rustc_span::{ByteSymbol, DesugaringKind, Ident, Span, Symbol, sym};
 
 use super::LoweringContext;
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(crate) fn lower_format_args(&mut self, sp: Span, fmt: &FormatArgs) -> hir::ExprKind<'hir> {
         // Never call the const constructor of `fmt::Arguments` if the
         // format_args!() had any arguments _before_ flattening/inlining.
@@ -230,7 +230,7 @@ enum ArgumentType {
 ///     <core::fmt::Argument>::new_…(arg)
 /// ```
 fn make_argument<'hir>(
-    ctx: &mut LoweringContext<'hir>,
+    ctx: &mut LoweringContext<'_, 'hir>,
     sp: Span,
     arg: &'hir hir::Expr<'hir>,
     ty: ArgumentType,
@@ -277,7 +277,7 @@ fn make_count(
 }
 
 fn expand_format_args<'hir>(
-    ctx: &mut LoweringContext<'hir>,
+    ctx: &mut LoweringContext<'_, 'hir>,
     macsp: Span,
     fmt: &FormatArgs,
     allow_const: bool,

compiler/rustc_ast_lowering/src/item.rs

@@ -28,10 +28,9 @@ use super::{
 };
 use crate::diagnostics::ConstComptimeFn;
 
-pub(super) struct ItemLowerer<'hir> {
+pub(super) struct ItemLowerer<'a, 'hir> {
     pub(super) tcx: TyCtxt<'hir>,
-    pub(super) resolver: &'hir ResolverAstLowering<'hir>,
-    pub(super) next_node_id: NodeId,
+    pub(super) resolver: &'a ResolverAstLowering<'hir>,
 }
 
 /// When we have a ty alias we *may* have two where clauses. To give the best diagnostics, we set the span
@@ -53,13 +52,13 @@ fn add_ty_alias_where_clause(
         if before.0 || !after.0 { before } else { after };
 }
 
-impl<'hir> ItemLowerer<'hir> {
+impl<'hir> ItemLowerer<'_, 'hir> {
     fn with_lctx(
         &mut self,
         owner: NodeId,
-        f: impl FnOnce(&mut LoweringContext<'hir>) -> hir::OwnerNode<'hir>,
+        f: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::OwnerNode<'hir>,
     ) -> hir::MaybeOwner<'hir> {
-        let mut lctx = LoweringContext::new(self.tcx, self.resolver, owner, self.next_node_id);
+        let mut lctx = LoweringContext::new(self.tcx, self.resolver, owner);
 
         let item = f(&mut lctx);
         debug_assert_eq!(lctx.current_hir_id_owner, item.def_id());
@@ -97,7 +96,7 @@ impl<'hir> ItemLowerer<'hir> {
     }
 }
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_mod(
         &mut self,
         items: &[Box<Item>],
@@ -1475,7 +1474,7 @@ impl<'hir> LoweringContext<'hir> {
     pub(crate) fn lower_coroutine_body_with_moved_arguments(
         &mut self,
         decl: &FnDecl,
-        lower_body: impl FnOnce(&mut LoweringContext<'hir>) -> hir::Expr<'hir>,
+        lower_body: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::Expr<'hir>,
         fn_decl_span: Span,
         body_span: Span,
         coroutine_kind: CoroutineKind,
@@ -1612,7 +1611,7 @@ impl<'hir> LoweringContext<'hir> {
             parameters.push(new_parameter);
         }
 
-        let mkbody = |this: &mut LoweringContext<'hir>| {
+        let mkbody = |this: &mut LoweringContext<'_, 'hir>| {
             // Create a block from the user's function body:
             let user_body = lower_body(this);
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -97,9 +97,9 @@ pub fn provide(providers: &mut Providers) {
     providers.lower_to_hir = lower_to_hir;
 }
 
-struct LoweringContext<'hir> {
+struct LoweringContext<'a, 'hir> {
     tcx: TyCtxt<'hir>,
-    resolver: &'hir ResolverAstLowering<'hir>,
+    resolver: &'a ResolverAstLowering<'hir>,
     current_disambiguator: PerParentDisambiguatorState,
 
     /// Used to allocate HIR nodes.
@@ -132,7 +132,7 @@ struct LoweringContext<'hir> {
     is_in_dyn_type: bool,
 
     current_hir_id_owner: hir::OwnerId,
-    owner: &'hir PerOwnerResolverData<'hir>,
+    owner: &'a PerOwnerResolverData<'hir>,
     item_local_id_counter: hir::ItemLocalId,
     trait_map: ItemLocalMap<&'hir [TraitCandidate<'hir>]>,
 
@@ -174,13 +174,8 @@ struct LoweringContext<'hir> {
     attribute_parser: AttributeParser<'hir>,
 }
 
-impl<'hir> LoweringContext<'hir> {
-    fn new(
-        tcx: TyCtxt<'hir>,
-        resolver: &'hir ResolverAstLowering<'hir>,
-        owner: NodeId,
-        next_node_id: NodeId,
-    ) -> Self {
+impl<'a, 'hir> LoweringContext<'a, 'hir> {
+    fn new(tcx: TyCtxt<'hir>, resolver: &'a ResolverAstLowering<'hir>, owner: NodeId) -> Self {
         let current_ast_owner = &resolver.owners[&owner];
         let current_hir_id_owner = hir::OwnerId { def_id: current_ast_owner.def_id };
         let current_disambiguator = resolver
@@ -210,7 +205,7 @@ impl<'hir> LoweringContext<'hir> {
             #[cfg(debug_assertions)]
             node_id_to_local_id: Default::default(),
             trait_map: Default::default(),
-            next_node_id,
+            next_node_id: resolver.next_node_id,
             node_id_to_def_id: NodeMap::default(),
             partial_res_overrides: NodeMap::default(),
 
@@ -459,14 +454,18 @@ enum TryBlockScope {
     Heterogeneous(HirId),
 }
 
-fn index_ast<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> (IndexVec<LocalDefId, Steal<AstOwner>>, NodeId) {
+fn index_ast<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    (): (),
+) -> IndexVec<LocalDefId, Steal<(Arc<ResolverAstLowering<'tcx>>, AstOwner)>> {
     // Queries that borrow `resolver_for_lowering`.
     tcx.ensure_done().output_filenames(());
     tcx.ensure_done().early_lint_checks(());
     tcx.ensure_done().get_lang_items(());
     tcx.ensure_done().debugger_visualizers(LOCAL_CRATE);
 
     let (resolver, krate) = tcx.resolver_for_lowering();
+    let mut resolver = resolver.steal();
     let mut krate = krate.steal();
 
     let mut indexer = Indexer {
@@ -476,19 +475,24 @@ fn index_ast<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> (IndexVec<LocalDefId, Steal<Ast
     };
     indexer.visit_crate(&mut krate);
     indexer.insert(CRATE_NODE_ID, AstOwner::Crate(Box::new(krate)));
-    return (indexer.index, indexer.next_node_id);
+    resolver.next_node_id = indexer.next_node_id;
 
-    struct Indexer<'s, 'ast> {
-        owners: &'s NodeMap<PerOwnerResolverData<'ast>>,
-        index: IndexVec<LocalDefId, Steal<AstOwner>>,
+    let index = indexer.index;
+    let resolver = Arc::new(resolver);
+    let index = index.into_iter().map(|owner| Steal::new((Arc::clone(&resolver), owner))).collect();
+    return index;
+
+    struct Indexer<'s, 'hir> {
+        owners: &'s NodeMap<PerOwnerResolverData<'hir>>,
+        index: IndexVec<LocalDefId, AstOwner>,
         next_node_id: NodeId,
     }
 
     impl Indexer<'_, '_> {
         fn insert(&mut self, id: NodeId, node: AstOwner) {
             let def_id = self.owners[&id].def_id;
-            self.index.ensure_contains_elem(def_id, || Steal::new(AstOwner::NonOwner));
-            self.index[def_id] = Steal::new(node);
+            self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner);
+            self.index[def_id] = node;
         }
 
         fn make_dummy<K>(
@@ -617,43 +621,46 @@ fn lower_to_hir(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::MaybeOwner<'_> {
     tcx.ensure_done().early_lint_checks(());
     tcx.ensure_done().debugger_visualizers(LOCAL_CRATE);
     tcx.ensure_done().get_lang_items(());
-    let (resolver, _) = tcx.resolver_for_lowering();
-    let (ast_index, next_node_id) = tcx.index_ast(());
-    let node = ast_index.get(def_id).map(Steal::steal);
-
-    let mut item_lowerer = item::ItemLowerer { tcx, resolver, next_node_id: *next_node_id };
-
-    // The item existed in the AST.
-    let parent_id = match node.as_ref() {
-        Some(AstOwner::Crate(c)) => return item_lowerer.lower_crate(&c),
-        Some(AstOwner::Item(item)) => return item_lowerer.lower_item(&item),
-        Some(AstOwner::TraitItem(item)) => {
-            return item_lowerer.lower_trait_item(&item);
-        }
-        Some(AstOwner::ImplItem(item)) => {
-            return item_lowerer.lower_impl_item(&item);
+    let ast_index = tcx.index_ast(());
+    let resolver_and_node = ast_index.get(def_id).map(Steal::steal);
+
+    let fallback_to_parent = |parent_id| {
+        // The item did not exist in the AST, it was created by its parent.
+        let mut parent_info = tcx.lower_to_hir(parent_id);
+        if let hir::MaybeOwner::NonOwner(hir_id) = parent_info {
+            parent_info = tcx.lower_to_hir(hir_id.owner);
         }
-        Some(AstOwner::ForeignItem(item)) => return item_lowerer.lower_foreign_item(&item),
-        Some(AstOwner::Synthetic(parent_id)) => *parent_id,
-        Some(AstOwner::NonOwner) | None => tcx.local_parent(def_id),
+
+        let parent_info = parent_info.unwrap();
+        *parent_info.children.get(&def_id).unwrap_or_else(|| {
+            panic!(
+                "{:?} does not appear in children of {:?}",
+                def_id,
+                parent_info.nodes.node().def_id()
+            )
+        })
     };
 
-    tcx.sess.time("drop_ast", || std::mem::drop(node));
+    let Some((resolver, node)) = resolver_and_node else {
+        return fallback_to_parent(tcx.local_parent(def_id));
+    };
 
-    // The item did not exist in the AST, it was created by its parent.
-    let mut parent_info = tcx.lower_to_hir(parent_id);
-    if let hir::MaybeOwner::NonOwner(hir_id) = parent_info {
-        parent_info = tcx.lower_to_hir(hir_id.owner);
-    }
+    let mut item_lowerer = item::ItemLowerer { tcx, resolver: &*resolver };
+
+    let item = match &node {
+        // The item existed in the AST.
+        AstOwner::Crate(c) => item_lowerer.lower_crate(&c),
+        AstOwner::Item(item) => item_lowerer.lower_item(&item),
+        AstOwner::TraitItem(item) => item_lowerer.lower_trait_item(&item),
+        AstOwner::ImplItem(item) => item_lowerer.lower_impl_item(&item),
+        AstOwner::ForeignItem(item) => item_lowerer.lower_foreign_item(&item),
+        AstOwner::Synthetic(parent_id) => fallback_to_parent(*parent_id),
+        AstOwner::NonOwner => fallback_to_parent(tcx.local_parent(def_id)),
+    };
 
-    let parent_info = parent_info.unwrap();
-    *parent_info.children.get(&def_id).unwrap_or_else(|| {
-        panic!(
-            "{:?} does not appear in children of {:?}",
-            def_id,
-            parent_info.nodes.node().def_id()
-        )
-    })
+    tcx.sess.time("drop_ast", || std::mem::drop(node));
+
+    item
 }
 
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -683,7 +690,7 @@ enum GenericArgsMode {
     Silence,
 }
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     fn create_def(
         &mut self,
         node_id: NodeId,
@@ -3138,7 +3145,7 @@ impl<'hir> GenericArgsCtor<'hir> {
             && self.parenthesized == hir::GenericArgsParentheses::No
     }
 
-    fn into_generic_args(self, this: &LoweringContext<'hir>) -> &'hir hir::GenericArgs<'hir> {
+    fn into_generic_args(self, this: &LoweringContext<'_, 'hir>) -> &'hir hir::GenericArgs<'hir> {
         let ga = hir::GenericArgs {
             args: this.arena.alloc_from_iter(self.args),
             constraints: self.constraints,