Implement anonymous lifetime lowering as a query

Author: fee1-dead

compiler/rustc_ast_lowering/src/item.rs

@@ -1,7 +1,7 @@
 use super::errors::{InvalidAbi, InvalidAbiReason, InvalidAbiSuggestion, MisplacedRelaxTraitBound};
 use super::ResolverAstLoweringExt;
-use super::{ImplTraitContext, ImplTraitPosition};
 use super::{FnDeclKind, LoweringContext, ParamMode};
+use super::{ImplTraitContext, ImplTraitPosition};
 
 use rustc_ast::ptr::P;
 use rustc_ast::*;
@@ -52,10 +52,10 @@ impl<'hir> ItemLowerer<'hir> {
         f: impl FnOnce(&mut LoweringContext<'hir>) -> hir::OwnerNode<'hir>,
     ) -> hir::MaybeOwner<'hir> {
         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());
-        
+
         let info = lctx.make_owner_info(item);
 
         hir::MaybeOwner::Owner(self.tcx.hir_arena.alloc(info))
@@ -707,13 +707,13 @@ impl<'hir> LoweringContext<'hir> {
         }
     }
 
-    fn lower_trait_item(
-        &mut self,
-        i: &AssocItem,
-    ) -> &'hir hir::TraitItem<'hir> {
+    fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
         let def_id = self.resolver.node_id_to_def_id[&i.id];
         let parent_id = self.tcx.local_parent(def_id);
-        let constness = self.tcx.get_attr(parent_id, sym::const_trait).map_or(Const::No, |attr| Const::Yes(attr.span));
+        let constness = self
+            .tcx
+            .get_attr(parent_id, sym::const_trait)
+            .map_or(Const::No, |attr| Const::Yes(attr.span));
 
         let hir_id = self.lower_node_id(i.id);
         self.lower_attrs(hir_id, &i.attrs);
@@ -847,10 +847,7 @@ impl<'hir> LoweringContext<'hir> {
         self.expr(span, hir::ExprKind::Err(guar))
     }
 
-    fn lower_impl_item(
-        &mut self,
-        i: &AssocItem,
-    ) -> &'hir hir::ImplItem<'hir> {
+    fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir hir::ImplItem<'hir> {
         let def_id = self.resolver.node_id_to_def_id[&i.id];
         let parent_id = self.tcx.local_parent(def_id);
         let parent_item = self.tcx.hir().expect_item(parent_id);
@@ -862,10 +859,13 @@ impl<'hir> LoweringContext<'hir> {
                 // is const. It doesn't matter whether the `impl` itself is const. Disallowing const fn from
                 // calling non-const impls are done through associated types.
                 if let Some(def_id) = impl_.of_trait.and_then(|tr| tr.trait_def_id()) {
-                    constness_of_trait = self.tcx.get_attr(def_id, sym::const_trait).map_or(Const::No, |attr| Const::Yes(attr.span))
+                    constness_of_trait = self
+                        .tcx
+                        .get_attr(def_id, sym::const_trait)
+                        .map_or(Const::No, |attr| Const::Yes(attr.span))
                 }
             }
-            _ => ()
+            _ => (),
         }
 
         // Since `default impl` is not yet implemented, this is always true in impls.

compiler/rustc_ast_lowering/src/lib.rs

@@ -48,12 +48,11 @@ use rustc_ast_pretty::pprust;
 use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::sorted_map::SortedMap;
-use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::steal::Steal;
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::unord::ExtendUnord;
 use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle, StashKey};
-use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
+use rustc_hir::def::{DefKind, FreshLifetimeResId, LifetimeRes, Namespace, PartialRes, PerNS, Res};
 use rustc_hir::def_id::{LocalDefId, LocalDefIdMap, LOCAL_CRATE};
 use rustc_hir::{self as hir};
 use rustc_hir::{
@@ -156,11 +155,7 @@ struct LoweringContext<'hir> {
 }
 
 impl<'hir> LoweringContext<'hir> {
-    fn new(
-        tcx: TyCtxt<'hir>,
-        resolver: &'hir ResolverAstLowering,
-        owner: NodeId,
-    ) -> Self {
+    fn new(tcx: TyCtxt<'hir>, resolver: &'hir ResolverAstLowering, owner: NodeId) -> Self {
         let current_hir_id_owner = hir::OwnerId { def_id: resolver.node_id_to_def_id[&owner] };
         Self {
             // Pseudo-globals.
@@ -428,7 +423,6 @@ fn index_ast<'tcx>(tcx: TyCtxt<'tcx>, (): ()) -> &'tcx IndexVec<LocalDefId, Stea
             visit::walk_item(self, item);
             self.insert(item.id, AstOwnerRef::Item(item));
         }
-        
 
         fn visit_assoc_item(&mut self, item: &'ast AssocItem, ctxt: visit::AssocCtxt) {
             visit::walk_item(self, item);
@@ -820,6 +814,14 @@ impl<'hir> LoweringContext<'hir> {
         Ident::new(ident.name, self.lower_span(ident.span))
     }
 
+    fn lower_fresh_lifetime_res(&mut self, id: FreshLifetimeResId, node_id: NodeId) -> LocalDefId {
+        let def_id = self.tcx.fresh_lifetime_def_id(id);
+        // make sure that this `NodeId` is known to us.
+        self.node_id_to_def_id.insert(node_id, def_id);
+        trace!(?self.current_hir_id_owner, ?def_id);
+        def_id
+    }
+
     /// Converts a lifetime into a new generic parameter.
     #[instrument(level = "debug", skip(self))]
     fn lifetime_res_to_generic_param(
@@ -833,17 +835,9 @@ impl<'hir> LoweringContext<'hir> {
             LifetimeRes::Param { .. } => {
                 (hir::ParamName::Plain(ident), hir::LifetimeParamKind::Explicit)
             }
-            LifetimeRes::Fresh { param, kind, .. } => {
-                // Late resolution delegates to us the creation of the `LocalDefId`.
-                let _def_id = self.create_def(
-                    self.current_hir_id_owner.def_id,
-                    param,
-                    kw::UnderscoreLifetime,
-                    DefKind::LifetimeParam,
-                    ident.span,
-                );
-                debug!(?_def_id);
-
+            LifetimeRes::Fresh { id, kind, param, .. } => {
+                debug_assert_eq!(param, node_id);
+                self.lower_fresh_lifetime_res(id, node_id);
                 (hir::ParamName::Fresh, hir::LifetimeParamKind::Elided(kind))
             }
             LifetimeRes::Static | LifetimeRes::Error => return None,
@@ -1697,15 +1691,9 @@ impl<'hir> LoweringContext<'hir> {
             let (old_def_id, missing_kind) = match res {
                 LifetimeRes::Param { param: old_def_id, binder: _ } => (old_def_id, None),
 
-                LifetimeRes::Fresh { param, kind, .. } => {
+                LifetimeRes::Fresh { id, kind, param, .. } => {
                     debug_assert_eq!(lifetime.ident.name, kw::UnderscoreLifetime);
-                    if let Some(old_def_id) = self.orig_opt_local_def_id(param) {
-                        (old_def_id, Some(kind))
-                    } else {
-                        self.dcx()
-                            .span_delayed_bug(lifetime.ident.span, "no def-id for fresh lifetime");
-                        continue;
-                    }
+                    (self.tcx.fresh_lifetime_def_id(id), Some(kind))
                 }
 
                 // Opaques do not capture `'static`
@@ -2117,8 +2105,8 @@ impl<'hir> LoweringContext<'hir> {
                 let param = self.get_remapped_def_id(param);
                 hir::LifetimeName::Param(param)
             }
-            LifetimeRes::Fresh { param, .. } => {
-                let param = self.local_def_id(param);
+            LifetimeRes::Fresh { id, .. } => {
+                let param = self.get_remapped_def_id(self.tcx.fresh_lifetime_def_id(id));
                 hir::LifetimeName::Param(param)
             }
             LifetimeRes::Infer => hir::LifetimeName::Infer,

compiler/rustc_ast_lowering/src/query.rs

@@ -1,13 +1,15 @@
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::svh::Svh;
+use rustc_hir::def::{DefKind, FreshLifetimeResId};
 use rustc_hir::def_id::{LocalDefId, LocalModDefId, StableCrateId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::*;
 use rustc_middle::hir::{nested_filter, ModuleItems};
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::query::{LocalCrate, Providers};
 use rustc_middle::ty::TyCtxt;
+use rustc_span::symbol::kw;
 use rustc_span::DUMMY_SP;
 
 use crate::{index_ast, lower_to_hir};
@@ -16,13 +18,25 @@ pub fn provide(providers: &mut Providers) {
     *providers = Providers {
         lower_to_hir,
         index_ast,
+        fresh_lifetime_def_id,
         crate_hash,
         hir_module_items,
         hir_crate_items,
         ..*providers
     };
 }
 
+fn fresh_lifetime_def_id(tcx: TyCtxt<'_>, id: FreshLifetimeResId) -> LocalDefId {
+    let (resolver, _) = tcx.resolver_for_lowering();
+    let (span, node_id) = resolver.fresh_lifetime_res_info[id];
+    let parent = *resolver
+        .node_id_to_def_id
+        .get(&node_id)
+        .expect("binder for fresh lifetime is not associated with a DefId?");
+
+    tcx.at(span).create_def(parent, kw::UnderscoreLifetime, DefKind::LifetimeParam).def_id()
+}
+
 fn crate_hash(tcx: TyCtxt<'_>, _: LocalCrate) -> Svh {
     let mut hir_body_nodes: Vec<_> = tcx
         .hir_crate_items(())

compiler/rustc_hir/src/def.rs

@@ -791,6 +791,15 @@ impl<Id> Res<Id> {
     }
 }
 
+rustc_index::newtype_index! {
+    /// Identifies a fresh lifetime, for example desugared from `'_`.
+    #[encodable]
+    #[orderable]
+    #[debug_format = "FreshLifetimeResId({})"]
+    #[derive(HashStable_Generic)]
+    pub struct FreshLifetimeResId {}
+}
+
 /// Resolution for a lifetime appearing in a type.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum LifetimeRes {
@@ -809,9 +818,9 @@ pub enum LifetimeRes {
     },
     /// Created a generic parameter for an anonymous lifetime.
     Fresh {
-        /// Id of the generic parameter that introduced it.
-        ///
-        /// Creating the associated `LocalDefId` is the responsibility of lowering.
+        /// The id for tracking creating the associated `LocalDefId`
+        id: FreshLifetimeResId,
+        /// The `NodeId` for ast lowering to link to the `LocalDefId`.
         param: NodeId,
         /// Id of the introducing place. See `Param`.
         binder: NodeId,

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -2080,7 +2080,11 @@ pub fn deny_non_region_late_bound(
 
     for (var, arg) in bound_vars {
         let Node::GenericParam(param) = tcx.hir_node_by_def_id(*var) else {
-            span_bug!(tcx.def_span(*var), "expected bound-var def-id to resolve to param");
+            span_bug!(
+                tcx.def_span(*var),
+                "expected bound-var def-id to resolve to param: {:?}",
+                tcx.hir_node_by_def_id(*var)
+            );
         };
 
         let what = match param.kind {

compiler/rustc_middle/src/hir/mod.rs

@@ -174,7 +174,8 @@ pub fn provide(providers: &mut Providers) {
             let parent_owner_id = tcx.local_def_id_to_hir_id(parent_def_id).owner;
             HirId {
                 owner: parent_owner_id,
-                local_id: tcx.lower_to_hir(parent_owner_id)
+                local_id: tcx
+                    .lower_to_hir(parent_owner_id)
                     .unwrap()
                     .parenting
                     .get(&owner_id.def_id)
@@ -183,9 +184,8 @@ pub fn provide(providers: &mut Providers) {
             }
         })
     };
-    providers.hir_attrs = |tcx, id| {
-        tcx.lower_to_hir(id.def_id).as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs)
-    };
+    providers.hir_attrs =
+        |tcx, id| tcx.lower_to_hir(id.def_id).as_owner().map_or(AttributeMap::EMPTY, |o| &o.attrs);
     providers.def_span = |tcx, def_id| tcx.hir().span(tcx.local_def_id_to_hir_id(def_id));
     providers.def_ident_span = |tcx, def_id| {
         let hir_id = tcx.local_def_id_to_hir_id(def_id);
@@ -216,7 +216,6 @@ pub fn provide(providers: &mut Providers) {
     providers.all_local_trait_impls = |tcx, ()| &tcx.resolutions(()).trait_impls;
     providers.expn_that_defined =
         |tcx, id| tcx.resolutions(()).expn_that_defined.get(&id).copied().unwrap_or(ExpnId::root());
-    providers.in_scope_traits_map = |tcx, id| {
-        tcx.lower_to_hir(id.def_id).as_owner().map(|owner_info| &owner_info.trait_map)
-    };
+    providers.in_scope_traits_map =
+        |tcx, id| tcx.lower_to_hir(id.def_id).as_owner().map(|owner_info| &owner_info.trait_map);
 }

compiler/rustc_middle/src/query/keys.rs

@@ -7,6 +7,7 @@ use crate::ty::fast_reject::SimplifiedType;
 use crate::ty::layout::{TyAndLayout, ValidityRequirement};
 use crate::ty::{self, Ty, TyCtxt};
 use crate::ty::{GenericArg, GenericArgsRef};
+use rustc_hir::def::FreshLifetimeResId;
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LocalModDefId, ModDefId, LOCAL_CRATE};
 use rustc_hir::hir_id::{HirId, OwnerId};
 use rustc_query_system::query::{DefIdCache, DefaultCache, SingleCache, VecCache};
@@ -563,6 +564,14 @@ impl Key for HirId {
     }
 }
 
+impl Key for FreshLifetimeResId {
+    type Cache<V> = DefaultCache<Self, V>;
+
+    fn default_span(&self, _tcx: TyCtxt<'_>) -> Span {
+        DUMMY_SP
+    }
+}
+
 impl Key for (LocalDefId, HirId) {
     type Cache<V> = DefaultCache<Self, V>;
 

compiler/rustc_middle/src/query/mod.rs

@@ -153,9 +153,13 @@ rustc_queries! {
         desc { "getting the source span" }
     }
 
+    query fresh_lifetime_def_id(key: rustc_hir::def::FreshLifetimeResId) -> LocalDefId {
+        desc { "getting the DefId for a fresh lifetime created during resolution" }
+    }
+
     query lower_to_hir(key: LocalDefId) -> hir::MaybeOwner<'tcx> {
         eval_always
-        desc { |tcx| "lower HIR for `{}`", tcx.def_path_str(key.to_def_id()) }
+        desc { |tcx| "lowering HIR for `{}`", tcx.def_path_str(key.to_def_id()) }
     }
 
     /// All items in the crate.

compiler/rustc_middle/src/ty/mod.rs

@@ -43,7 +43,9 @@ use rustc_data_structures::tagged_ptr::CopyTaggedPtr;
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::{Diag, ErrorGuaranteed, StashKey};
 use rustc_hir as hir;
-use rustc_hir::def::{CtorKind, CtorOf, DefKind, DocLinkResMap, LifetimeRes, Res};
+use rustc_hir::def::{
+    CtorKind, CtorOf, DefKind, DocLinkResMap, FreshLifetimeResId, LifetimeRes, Res,
+};
 use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, LocalDefIdMap};
 use rustc_index::IndexVec;
 use rustc_macros::{
@@ -212,6 +214,8 @@ pub struct ResolverAstLowering {
     pub lifetimes_res_map: NodeMap<LifetimeRes>,
     /// Lifetime parameters that lowering will have to introduce.
     pub extra_lifetime_params_map: NodeMap<Vec<(Ident, ast::NodeId, LifetimeRes)>>,
+    /// Lifetime parameters that resolver did not create `DefId`s for.
+    pub fresh_lifetime_res_info: IndexVec<FreshLifetimeResId, (Span, ast::NodeId)>,
 
     pub next_node_id: ast::NodeId,