Steal ResolverAstLowering when indexing AST.

Author: cjgillot

compiler/rustc_ast_lowering/src/asm.rs

@@ -20,7 +20,7 @@ use super::errors::{
 };
 use crate::{AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, 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

@@ -105,7 +105,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,
@@ -665,13 +665,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()
@@ -682,7 +682,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 {
@@ -174,7 +174,7 @@ impl<'hir> GenericsGenerationResults<'hir> {
     pub(super) fn all_params(
         &mut self,
         span: Span,
-        ctx: &mut LoweringContext<'hir>,
+        ctx: &mut LoweringContext<'_, 'hir>,
     ) -> impl Iterator<Item = hir::GenericParam<'hir>> {
         // Now we always call `into_hir_generics` both on child and parent,
         // however in future we would not do that, when scenarios like
@@ -208,7 +208,7 @@ impl<'hir> GenericsGenerationResults<'hir> {
     pub(super) fn all_predicates(
         &mut self,
         span: Span,
-        ctx: &mut LoweringContext<'hir>,
+        ctx: &mut LoweringContext<'_, 'hir>,
     ) -> impl Iterator<Item = hir::WherePredicate<'hir>> {
         // Now we always call `into_hir_generics` both on child and parent,
         // however in future we would not do that, when scenarios like
@@ -226,7 +226,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

@@ -50,7 +50,7 @@ impl<'v> rustc_ast::visit::Visitor<'v> for WillCreateDefIdsVisitor {
     }
 }
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_exprs(&mut self, exprs: &[Box<Expr>]) -> &'hir [hir::Expr<'hir>] {
         self.arena.alloc_from_iter(exprs.iter().map(|x| self.lower_expr_mut(x)))
     }
@@ -1230,7 +1230,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/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

@@ -24,10 +24,9 @@ use super::{
     RelaxedBoundForbiddenReason, RelaxedBoundPolicy, ResolverAstLoweringExt,
 };
 
-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
@@ -49,13 +48,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());
@@ -93,7 +92,7 @@ impl<'hir> ItemLowerer<'hir> {
     }
 }
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(super) fn lower_mod(
         &mut self,
         items: &[Box<Item>],
@@ -1462,7 +1461,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,
@@ -1599,7 +1598,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

@@ -89,9 +89,9 @@ mod pat;
 mod path;
 pub mod stability;
 
-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.
@@ -160,13 +160,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 registered_tools = tcx.registered_tools(()).iter().map(|x| x.name).collect();
         let current_hir_id_owner = hir::OwnerId { def_id: resolver.node_id_to_def_id[&owner] };
         let current_disambiguator = resolver
@@ -193,7 +188,7 @@ impl<'hir> LoweringContext<'hir> {
             #[cfg(debug_assertions)]
             node_id_to_local_id: [(owner, hir::ItemLocalId::ZERO)].into_iter().collect(),
             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(),
 
@@ -457,14 +452,15 @@ enum TryBlockScope {
 pub fn index_ast<'tcx>(
     tcx: TyCtxt<'tcx>,
     (): (),
-) -> (IndexVec<LocalDefId, Steal<AstOwner>>, NodeId) {
+) -> 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 {
@@ -474,19 +470,24 @@ pub fn index_ast<'tcx>(
     };
     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;
+
+    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> {
         node_id_to_def_id: &'s NodeMap<LocalDefId>,
-        index: IndexVec<LocalDefId, Steal<AstOwner>>,
+        index: IndexVec<LocalDefId, AstOwner>,
         next_node_id: NodeId,
     }
 
     impl Indexer<'_> {
         fn insert(&mut self, id: NodeId, node: AstOwner) {
             let def_id = self.node_id_to_def_id[&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>(
@@ -611,43 +612,46 @@ pub 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)]
@@ -677,7 +681,7 @@ enum GenericArgsMode {
     Silence,
 }
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     fn create_def(
         &mut self,
         node_id: NodeId,
@@ -3109,7 +3113,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,

compiler/rustc_ast_lowering/src/pat.rs

@@ -14,7 +14,7 @@ use super::{
     AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
 };
 
-impl<'hir> LoweringContext<'hir> {
+impl<'hir> LoweringContext<'_, 'hir> {
     pub(crate) fn lower_pat(&mut self, pattern: &Pat) -> &'hir hir::Pat<'hir> {
         self.arena.alloc(self.lower_pat_mut(pattern))
     }