Remove ResolverAstLoweringExt, try to address perf issues

aerooneqq · aerooneqq · commit e9aa88f2d61b · 2026-03-11T09:06:21.000+03:00
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
@@ -19,9 +19,7 @@ use super::errors::{
     InvalidRegisterClass, RegisterClassOnlyClobber, RegisterClassOnlyClobberStable,
     RegisterConflict,
 };
-use crate::{
-    AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, ParamMode, ResolverAstLoweringExt,
-};
+use crate::{AllowReturnTypeNotation, ImplTraitContext, ImplTraitPosition, ParamMode};
 
 impl<'hir> LoweringContext<'_, '_, 'hir> {
     pub(crate) fn lower_inline_asm(
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -60,7 +60,7 @@ use crate::delegation::generics::{GenericsGenerationResult, GenericsGenerationRe
 use crate::errors::{CycleInDelegationSignatureResolution, UnresolvedDelegationCallee};
 use crate::{
     AllowReturnTypeNotation, CombinedResolverAstLowering, GenericArgsMode, ImplTraitContext,
-    ImplTraitPosition, LoweringContext, ParamMode, ResolverAstLoweringExt,
+    ImplTraitPosition, LoweringContext, ParamMode,
 };
 
 mod generics;
@@ -139,9 +139,12 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
         match self.tcx.def_kind(def_id) {
             DefKind::Fn => false,
             DefKind::AssocFn => match def_id.as_local() {
-                Some(local_def_id) => {
-                    self.resolver.delegation_fn_sig(local_def_id).is_some_and(|sig| sig.has_self)
-                }
+                Some(local_def_id) => self
+                    .resolver
+                    .base
+                    .delegation_fn_sigs
+                    .get(&local_def_id)
+                    .is_some_and(|sig| sig.has_self),
                 None => self.tcx.associated_item(def_id).is_method(),
             },
             _ => span_bug!(span, "unexpected DefKind for delegation item"),
@@ -157,7 +160,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
 
         // Delegation can be unresolved in illegal places such as function bodies in extern blocks (see #151356)
         let ids = if let Some(delegation_info) =
-            self.resolver.delegation_info(self.local_def_id(item_id))
+            self.resolver.base.delegation_infos.get(&self.local_def_id(item_id))
         {
             self.get_delegation_ids(delegation_info.resolution_node, span)
         } else {
@@ -342,10 +345,10 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
 
     fn get_attrs(&self, local_id: LocalDefId) -> &DelegationAttrs {
         // local_id can correspond either to a function or other delegation
-        if let Some(fn_sig) = self.resolver.delegation_fn_sig(local_id) {
+        if let Some(fn_sig) = self.resolver.base.delegation_fn_sigs.get(&local_id) {
             &fn_sig.attrs
         } else {
-            &self.resolver.delegation_info(local_id).unwrap().attrs
+            &self.resolver.base.delegation_infos[&local_id].attrs
         }
     }
 
@@ -376,7 +379,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
             // it means that we refer to another delegation as a callee, so in order to obtain
             // a signature DefId we obtain NodeId of the callee delegation and try to get signature from it.
             if let Some(local_id) = def_id.as_local()
-                && let Some(delegation_info) = self.resolver.delegation_info(local_id)
+                && let Some(delegation_info) = self.resolver.base.delegation_infos.get(&local_id)
             {
                 node_id = delegation_info.resolution_node;
                 if visited.contains(&node_id) {
@@ -400,7 +403,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
     // Function parameter count, including C variadic `...` if present.
     fn param_count(&self, def_id: DefId) -> (usize, bool /*c_variadic*/) {
         if let Some(local_sig_id) = def_id.as_local() {
-            match self.resolver.delegation_fn_sig(local_sig_id) {
+            match self.resolver.base.delegation_fn_sigs.get(&local_sig_id) {
                 Some(sig) => (sig.param_count, sig.c_variadic),
                 None => (0, false),
             }
@@ -455,7 +458,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
         span: Span,
     ) -> hir::FnSig<'hir> {
         let header = if let Some(local_sig_id) = sig_id.as_local() {
-            match self.resolver.delegation_fn_sig(local_sig_id) {
+            match self.resolver.base.delegation_fn_sigs.get(&local_sig_id) {
                 Some(sig) => {
                     let parent = self.tcx.parent(sig_id);
                     // HACK: we override the default safety instead of generating attributes from the ether.
diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -10,7 +10,7 @@ use rustc_span::symbol::kw;
 use rustc_span::{DUMMY_SP, Ident, Span};
 use thin_vec::{ThinVec, thin_vec};
 
-use crate::{AstOwner, LoweringContext, ResolverAstLoweringExt};
+use crate::{AstOwner, LoweringContext};
 
 pub(super) enum DelegationGenerics<T> {
     /// User-specified args are present: `reuse foo::<String>;`.
@@ -293,7 +293,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
                 p.id,
                 self.tcx
                     .create_def(
-                        self.resolver.def_id(item_id).unwrap(),
+                        self.local_def_id(item_id),
                         Some(p.ident.name),
                         match p.kind {
                             GenericParamKind::Lifetime => DefKind::LifetimeParam,
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -24,9 +24,7 @@ use super::errors::{
     InclusiveRangeWithNoEnd, MatchArmWithNoBody, NeverPatternWithBody, NeverPatternWithGuard,
     UnderscoreExprLhsAssign,
 };
-use super::{
-    GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt,
-};
+use super::{GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode};
 use crate::errors::{InvalidLegacyConstGenericArg, UseConstGenericArg, YieldInClosure};
 use crate::{AllowReturnTypeNotation, FnDeclKind, ImplTraitPosition, TryBlockScope};
 
@@ -1612,8 +1610,8 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
     fn lower_loop_destination(&mut self, destination: Option<(NodeId, Label)>) -> hir::Destination {
         let target_id = match destination {
             Some((id, _)) => {
-                if let Some(loop_id) = self.resolver.get_label_res(id) {
-                    let local_id = self.ident_and_label_to_local_id[&loop_id];
+                if let Some(loop_id) = self.resolver.base.label_res_map.get(&id) {
+                    let local_id = self.ident_and_label_to_local_id[loop_id];
                     let loop_hir_id = HirId { owner: self.current_hir_id_owner, local_id };
                     Ok(loop_hir_id)
                 } else {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -22,7 +22,7 @@ use super::errors::{InvalidAbi, InvalidAbiSuggestion, TupleStructWithDefault, Un
 use super::stability::{enabled_names, gate_unstable_abi};
 use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
-    RelaxedBoundForbiddenReason, RelaxedBoundPolicy, ResolverAstLoweringExt,
+    RelaxedBoundForbiddenReason, RelaxedBoundPolicy,
 };
 use crate::CombinedResolverAstLowering;
 
@@ -78,7 +78,7 @@ impl<'hir> ItemLowerer<'_, '_, 'hir> {
             match node {
                 AstOwner::NonOwner => {}
                 AstOwner::Crate(c) => {
-                    assert_eq!(self.resolver.def_id(CRATE_NODE_ID).unwrap(), CRATE_DEF_ID);
+                    assert_eq!(self.resolver.base.node_id_to_def_id[&CRATE_NODE_ID], CRATE_DEF_ID);
                     self.with_lctx(CRATE_NODE_ID, |lctx| {
                         let module = lctx.lower_mod(&c.items, &c.spans);
                         // FIXME(jdonszelman): is dummy span ever a problem here?
@@ -1831,8 +1831,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
             .collect();
 
         // Introduce extra lifetimes if late resolution tells us to.
-        let extra_lifetimes =
-            self.resolver.extra_lifetime_params(parent_node_id).cloned().unwrap_or_default();
+        let extra_lifetimes = self.resolver.extra_lifetime_params(parent_node_id);
         params.extend(extra_lifetimes.into_iter().filter_map(|(ident, node_id, res)| {
             self.lifetime_res_to_generic_param(
                 ident,
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -56,9 +56,8 @@ use rustc_hir::{
     LifetimeSyntax, ParamName, Target, TraitCandidate, find_attr,
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
-use rustc_macros::extension;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{DelegationFnSig, DelegationInfo, ResolverAstLowering, TyCtxt};
+use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
 use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use rustc_span::{DUMMY_SP, DesugaringKind, Span};
@@ -257,60 +256,20 @@ struct CombinedResolverAstLowering<'a, 'tcx> {
     mut_part: MutableResolverAstLowering,
 }
 
-impl ResolverAstLoweringExt for CombinedResolverAstLowering<'_, '_> {
+impl CombinedResolverAstLowering<'_, '_> {
     #[inline]
-    fn legacy_const_generic_args(&self, expr: &Expr, tcx: TyCtxt<'_>) -> Option<Vec<usize>> {
-        self.base.legacy_const_generic_args(expr, tcx)
-    }
-
-    #[inline]
-    fn get_partial_res(&self, id: NodeId) -> Option<PartialRes> {
-        self.mut_part.partial_res_map.get(&id).cloned().or_else(|| self.base.get_partial_res(id))
-    }
-
-    #[inline]
-    fn get_import_res(&self, id: NodeId) -> Option<&PerNS<Option<Res<NodeId>>>> {
-        self.base.get_import_res(id)
-    }
-
-    #[inline]
-    fn get_label_res(&self, id: NodeId) -> Option<NodeId> {
-        self.base.get_label_res(id)
-    }
-
-    #[inline]
-    fn get_lifetime_res(&self, id: NodeId) -> Option<LifetimeRes> {
-        self.base.get_lifetime_res(id)
-    }
+    fn get_partial_res(&self, id: NodeId) -> Option<&PartialRes> {
+        let base_res = self.base.partial_res_map.get(&id);
 
-    #[inline]
-    fn extra_lifetime_params(&self, id: NodeId) -> Option<&Vec<(Ident, NodeId, LifetimeRes)>> {
-        self.base.extra_lifetime_params(id)
-    }
-
-    #[inline]
-    fn delegation_fn_sig(&self, id: LocalDefId) -> Option<&DelegationFnSig> {
-        self.base.delegation_fn_sig(id)
-    }
-
-    #[inline]
-    fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
-        self.base.delegation_info(id)
-    }
-
-    #[inline]
-    fn def_id(&self, id: NodeId) -> Option<LocalDefId> {
-        self.mut_part.node_id_to_def_id.get(&id).copied().or_else(|| self.base.def_id(id))
-    }
+        // Partial res map is modified only in delegation for now, so it will
+        // be empty most of the time.
+        if self.mut_part.partial_res_map.is_empty() {
+            return base_res;
+        }
 
-    #[inline]
-    fn lifetime_elision_allowed(&self, id: NodeId) -> bool {
-        self.base.lifetime_elision_allowed(id)
+        self.mut_part.partial_res_map.get(&id).or(base_res)
     }
-}
 
-#[extension(trait ResolverAstLoweringExt)]
-impl ResolverAstLowering<'_> {
     fn legacy_const_generic_args(&self, expr: &Expr, tcx: TyCtxt<'_>) -> Option<Vec<usize>> {
         let ExprKind::Path(None, path) = &expr.kind else {
             return None;
@@ -339,27 +298,10 @@ impl ResolverAstLowering<'_> {
         .map(|fn_indexes| fn_indexes.iter().map(|(num, _)| *num).collect())
     }
 
-    #[inline]
-    fn get_partial_res(&self, id: NodeId) -> Option<PartialRes> {
-        self.partial_res_map.get(&id).copied()
-    }
-
-    /// Obtains per-namespace resolutions for `use` statement with the given `NodeId`.
-    #[inline]
-    fn get_import_res(&self, id: NodeId) -> Option<&PerNS<Option<Res<NodeId>>>> {
-        self.import_res_map.get(&id)
-    }
-
-    /// Obtains resolution for a label with the given `NodeId`.
-    #[inline]
-    fn get_label_res(&self, id: NodeId) -> Option<NodeId> {
-        self.label_res_map.get(&id).copied()
-    }
-
     /// Obtains resolution for a lifetime with the given `NodeId`.
     #[inline]
     fn get_lifetime_res(&self, id: NodeId) -> Option<LifetimeRes> {
-        self.lifetimes_res_map.get(&id).copied()
+        self.base.lifetimes_res_map.get(&id).copied()
     }
 
     /// Obtain the list of lifetimes parameters to add to an item.
@@ -370,28 +312,8 @@ impl ResolverAstLowering<'_> {
     /// The extra lifetimes that appear from the parenthesized `Fn`-trait desugaring
     /// should appear at the enclosing `PolyTraitRef`.
     #[inline]
-    fn extra_lifetime_params(&self, id: NodeId) -> Option<&Vec<(Ident, NodeId, LifetimeRes)>> {
-        self.extra_lifetime_params_map.get(&id)
-    }
-
-    #[inline]
-    fn delegation_fn_sig(&self, id: LocalDefId) -> Option<&DelegationFnSig> {
-        self.delegation_fn_sigs.get(&id)
-    }
-
-    #[inline]
-    fn delegation_info(&self, id: LocalDefId) -> Option<&DelegationInfo> {
-        self.delegation_infos.get(&id)
-    }
-
-    #[inline]
-    fn def_id(&self, id: NodeId) -> Option<LocalDefId> {
-        self.node_id_to_def_id.get(&id).copied()
-    }
-
-    #[inline]
-    fn lifetime_elision_allowed(&self, id: NodeId) -> bool {
-        self.lifetime_elision_allowed.contains(&id)
+    fn extra_lifetime_params(&self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)> {
+        self.base.extra_lifetime_params_map.get(&id).cloned().unwrap_or_default()
     }
 }
 
@@ -712,7 +634,12 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
     /// Given the id of some node in the AST, finds the `LocalDefId` associated with it by the name
     /// resolver (if any).
     fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId> {
-        self.resolver.def_id(node)
+        // We are only inserting new ids, not rewriting already existent.
+        if let Some(&def_id) = self.resolver.base.node_id_to_def_id.get(&node) {
+            return Some(def_id);
+        }
+
+        self.resolver.mut_part.node_id_to_def_id.get(&node).copied()
     }
 
     fn local_def_id(&self, node: NodeId) -> LocalDefId {
@@ -887,7 +814,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
     }
 
     fn lower_import_res(&mut self, id: NodeId, span: Span) -> PerNS<Option<Res>> {
-        let per_ns = self.resolver.get_import_res(id).copied().unwrap_or_default();
+        let per_ns = self.resolver.base.import_res_map.get(&id).copied().unwrap_or_default();
         let per_ns = per_ns.map(|res| res.map(|res| self.lower_res(res)));
         if per_ns.is_empty() {
             // Propagate the error to all namespaces, just to be sure.
@@ -1019,8 +946,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
     ) -> &'hir [hir::GenericParam<'hir>] {
         // Start by creating params for extra lifetimes params, as this creates the definitions
         // that may be referred to by the AST inside `generic_params`.
-        let extra_lifetimes =
-            self.resolver.extra_lifetime_params(binder).cloned().unwrap_or_default();
+        let extra_lifetimes = self.resolver.extra_lifetime_params(binder);
         debug!(?extra_lifetimes);
         let extra_lifetimes: Vec<_> = extra_lifetimes
             .into_iter()
@@ -1859,7 +1785,11 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
             inputs,
             output,
             c_variadic,
-            lifetime_elision_allowed: self.resolver.lifetime_elision_allowed(fn_node_id),
+            lifetime_elision_allowed: self
+                .resolver
+                .base
+                .lifetime_elision_allowed
+                .contains(&fn_node_id),
             implicit_self: decl.inputs.get(0).map_or(hir::ImplicitSelfKind::None, |arg| {
                 let is_mutable_pat = matches!(
                     arg.pat.kind,
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
@@ -12,7 +12,7 @@ use rustc_span::{DesugaringKind, Ident, Span};
 use super::errors::{
     ArbitraryExpressionInPattern, ExtraDoubleDot, MisplacedDoubleDot, SubTupleBinding,
 };
-use super::{ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt};
+use super::{ImplTraitContext, LoweringContext, ParamMode};
 use crate::{AllowReturnTypeNotation, ImplTraitPosition};
 
 impl<'hir> LoweringContext<'_, '_, 'hir> {
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
@@ -16,7 +16,7 @@ use super::errors::{
 };
 use super::{
     AllowReturnTypeNotation, GenericArgsCtor, GenericArgsMode, ImplTraitContext, ImplTraitPosition,
-    LifetimeRes, LoweringContext, ParamMode, ResolverAstLoweringExt,
+    LifetimeRes, LoweringContext, ParamMode,
 };
 
 impl<'hir> LoweringContext<'_, '_, 'hir> {
@@ -41,7 +41,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
             });
 
         let partial_res =
-            self.resolver.get_partial_res(id).unwrap_or_else(|| PartialRes::new(Res::Err));
+            self.resolver.get_partial_res(id).copied().unwrap_or_else(|| PartialRes::new(Res::Err));
         let base_res = partial_res.base_res();
         let unresolved_segments = partial_res.unresolved_segments();
 
