Abstract resolver

Author: aerooneqq

compiler/rustc_ast_lowering/src/asm.rs

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

compiler/rustc_ast_lowering/src/block.rs

@@ -4,9 +4,9 @@ use rustc_hir::Target;
 use rustc_span::sym;
 use smallvec::SmallVec;
 
-use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext};
+use crate::{ImplTraitContext, ImplTraitPosition, LoweringContext, ResolverAstLoweringExt};
 
-impl<'hir> LoweringContext<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(super) fn lower_block(
         &mut self,
         b: &Block,

compiler/rustc_ast_lowering/src/contract.rs

@@ -2,9 +2,9 @@ use std::sync::Arc;
 
 use thin_vec::thin_vec;
 
-use crate::LoweringContext;
+use crate::{LoweringContext, ResolverAstLoweringExt};
 
-impl<'hir> LoweringContext<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     /// 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

@@ -59,8 +59,8 @@ use smallvec::SmallVec;
 use crate::delegation::generics::{GenericsGenerationResult, GenericsGenerationResults};
 use crate::errors::{CycleInDelegationSignatureResolution, UnresolvedDelegationCallee};
 use crate::{
-    AllowReturnTypeNotation, CombinedResolverAstLowering, GenericArgsMode, ImplTraitContext,
-    ImplTraitPosition, LoweringContext, ParamMode, ResolverAstLoweringExt,
+    AllowReturnTypeNotation, GenericArgsMode, ImplTraitContext, ImplTraitPosition, LoweringContext,
+    ParamMode, ResolverAstLoweringExt,
 };
 
 mod generics;
@@ -134,7 +134,7 @@ impl DelegationIds {
     }
 }
 
-impl<'hir> LoweringContext<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
             DefKind::Fn => false,
@@ -814,25 +814,25 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
     }
 }
 
-struct SelfResolver<'a, 'b, 'tcx> {
-    resolver: &'a mut CombinedResolverAstLowering<'b, 'tcx>,
+struct SelfResolver<'a, 'tcx> {
+    resolver: &'a mut dyn ResolverAstLoweringExt<'tcx>,
     path_id: NodeId,
     self_param_id: NodeId,
 }
 
-impl SelfResolver<'_, '_, '_> {
+impl SelfResolver<'_, '_> {
     fn try_replace_id(&mut self, id: NodeId) {
         if let Some(res) = self.resolver.get_partial_res(id)
             && let Some(Res::Local(sig_id)) = res.full_res()
             && sig_id == self.path_id
         {
             let new_res = PartialRes::new(Res::Local(self.self_param_id));
-            self.resolver.mut_part.partial_res_map.insert(id, new_res);
+            self.resolver.insert_partial_res(id, new_res);
         }
     }
 }
 
-impl<'ast, 'a> Visitor<'ast> for SelfResolver<'a, '_, '_> {
+impl<'ast, 'a> Visitor<'ast> for SelfResolver<'a, '_> {
     fn visit_id(&mut self, id: NodeId) {
         self.try_replace_id(id);
     }

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -58,9 +58,9 @@ impl<T> DelegationGenerics<T> {
 }
 
 impl<'hir> HirOrAstGenerics<'hir> {
-    pub(super) fn into_hir_generics(
+    pub(super) fn into_hir_generics<R: ResolverAstLoweringExt<'hir>>(
         &mut self,
-        ctx: &mut LoweringContext<'_, '_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, R>,
         item_id: NodeId,
         span: Span,
     ) -> &mut HirOrAstGenerics<'hir> {
@@ -98,9 +98,9 @@ impl<'hir> HirOrAstGenerics<'hir> {
         }
     }
 
-    pub(super) fn into_generic_args(
+    pub(super) fn into_generic_args<R: ResolverAstLoweringExt<'hir>>(
         &self,
-        ctx: &mut LoweringContext<'_, '_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, R>,
         add_lifetimes: bool,
         span: Span,
     ) -> Option<&'hir hir::GenericArgs<'hir>> {
@@ -136,11 +136,11 @@ impl<'a> GenericsGenerationResult<'a> {
 }
 
 impl<'hir> GenericsGenerationResults<'hir> {
-    pub(super) fn all_params(
+    pub(super) fn all_params<R: ResolverAstLoweringExt<'hir>>(
         &mut self,
         item_id: NodeId,
         span: Span,
-        ctx: &mut LoweringContext<'_, '_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, R>,
     ) -> 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
@@ -178,11 +178,11 @@ impl<'hir> GenericsGenerationResults<'hir> {
     /// and `generate_lifetime_predicate` functions) we need to add them to delegation generics.
     /// Those predicates will not affect resulting predicate inheritance and folding
     /// in `rustc_hir_analysis`, as we inherit all predicates from delegation signature.
-    pub(super) fn all_predicates(
+    pub(super) fn all_predicates<R: ResolverAstLoweringExt<'hir>>(
         &mut self,
         item_id: NodeId,
         span: Span,
-        ctx: &mut LoweringContext<'_, '_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir, R>,
     ) -> 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
@@ -207,7 +207,7 @@ impl<'hir> GenericsGenerationResults<'hir> {
     }
 }
 
-impl<'hir> LoweringContext<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(super) fn lower_delegation_generics(
         &mut self,
         delegation: &Delegation,
@@ -289,22 +289,22 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
 
             // Note that we use self.disambiguator here, if we will create new every time
             // we will get ICE if params have the same name.
-            self.resolver.mut_part.node_id_to_def_id.insert(
-                p.id,
-                self.tcx
-                    .create_def(
-                        self.resolver.def_id(item_id).unwrap(),
-                        Some(p.ident.name),
-                        match p.kind {
-                            GenericParamKind::Lifetime => DefKind::LifetimeParam,
-                            GenericParamKind::Type { .. } => DefKind::TyParam,
-                            GenericParamKind::Const { .. } => DefKind::ConstParam,
-                        },
-                        None,
-                        &mut self.disambiguator,
-                    )
-                    .def_id(),
-            );
+            let def_id = self
+                .tcx
+                .create_def(
+                    self.resolver.def_id(item_id).unwrap(),
+                    Some(p.ident.name),
+                    match p.kind {
+                        GenericParamKind::Lifetime => DefKind::LifetimeParam,
+                        GenericParamKind::Type { .. } => DefKind::TyParam,
+                        GenericParamKind::Const { .. } => DefKind::ConstParam,
+                    },
+                    None,
+                    &mut self.disambiguator,
+                )
+                .def_id();
+
+            self.resolver.insert_new_def_id(p.id, def_id);
         }
 
         // Fallback to default generic param lowering, we modified them in the loop above.
@@ -509,7 +509,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
 
         let node_id = self.next_node_id();
 
-        self.resolver.mut_part.partial_res_map.insert(node_id, hir::def::PartialRes::new(res));
+        self.resolver.insert_partial_res(node_id, hir::def::PartialRes::new(res));
 
         GenericParamKind::Const {
             ty: Box::new(Ty {

compiler/rustc_ast_lowering/src/expr.rs

@@ -53,7 +53,7 @@ impl<'v> rustc_ast::visit::Visitor<'v> for WillCreateDefIdsVisitor {
     }
 }
 
-impl<'hir> LoweringContext<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     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)))
     }
@@ -1232,7 +1232,10 @@ 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<'hir, R: ResolverAstLoweringExt<'hir>>(
+            lower_ctx: &mut LoweringContext<'_, 'hir, R>,
+            lhs: &Expr,
+        ) -> bool {
             match &lhs.kind {
                 ExprKind::Array(..)
                 | ExprKind::Struct(..)

compiler/rustc_ast_lowering/src/format.rs

@@ -7,8 +7,9 @@ use rustc_session::config::FmtDebug;
 use rustc_span::{ByteSymbol, DesugaringKind, Ident, Span, Symbol, sym};
 
 use super::LoweringContext;
+use crate::ResolverAstLoweringExt;
 
-impl<'hir> LoweringContext<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     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.
@@ -229,8 +230,8 @@ enum ArgumentType {
 /// ```text
 ///     <core::fmt::Argument>::new_…(arg)
 /// ```
-fn make_argument<'hir>(
-    ctx: &mut LoweringContext<'_, '_, 'hir>,
+fn make_argument<'hir, R: ResolverAstLoweringExt<'hir>>(
+    ctx: &mut LoweringContext<'_, 'hir, R>,
     sp: Span,
     arg: &'hir hir::Expr<'hir>,
     ty: ArgumentType,
@@ -276,8 +277,8 @@ fn make_count(
     }
 }
 
-fn expand_format_args<'hir>(
-    ctx: &mut LoweringContext<'_, '_, 'hir>,
+fn expand_format_args<'hir, R: ResolverAstLoweringExt<'hir>>(
+    ctx: &mut LoweringContext<'_, 'hir, R>,
     macsp: Span,
     fmt: &FormatArgs,
     allow_const: bool,

compiler/rustc_ast_lowering/src/item.rs

@@ -24,11 +24,10 @@ use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
     RelaxedBoundForbiddenReason, RelaxedBoundPolicy, ResolverAstLoweringExt,
 };
-use crate::CombinedResolverAstLowering;
 
-pub(super) struct ItemLowerer<'a, 'b, 'hir> {
+pub(super) struct ItemLowerer<'a, 'hir, R: ResolverAstLoweringExt<'hir>> {
     pub(super) tcx: TyCtxt<'hir>,
-    pub(super) resolver: &'a mut CombinedResolverAstLowering<'b, 'hir>,
+    pub(super) resolver: &'a mut R,
     pub(super) ast_index: &'a IndexSlice<LocalDefId, AstOwner<'a>>,
     pub(super) owners: &'a mut IndexVec<LocalDefId, hir::MaybeOwner<'hir>>,
 }
@@ -52,13 +51,13 @@ fn add_ty_alias_where_clause(
         if before.0 || !after.0 { before } else { after };
 }
 
-impl<'hir> ItemLowerer<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> ItemLowerer<'_, 'hir, R> {
     fn with_lctx(
         &mut self,
         owner: NodeId,
-        f: impl FnOnce(&mut LoweringContext<'_, '_, 'hir>) -> hir::OwnerNode<'hir>,
+        f: impl FnOnce(&mut LoweringContext<'_, 'hir, R>) -> hir::OwnerNode<'hir>,
     ) {
-        let mut lctx = LoweringContext::new(self.tcx, self.ast_index, &mut self.resolver);
+        let mut lctx = LoweringContext::new(self.tcx, self.ast_index, self.resolver);
         lctx.with_hir_id_owner(owner, |lctx| f(lctx));
 
         for (def_id, info) in lctx.children {
@@ -100,7 +99,7 @@ impl<'hir> ItemLowerer<'_, '_, 'hir> {
     }
 }
 
-impl<'hir> LoweringContext<'_, '_, 'hir> {
+impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
     pub(super) fn lower_mod(
         &mut self,
         items: &[Box<Item>],
@@ -1476,7 +1475,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, R>) -> hir::Expr<'hir>,
         fn_decl_span: Span,
         body_span: Span,
         coroutine_kind: CoroutineKind,
@@ -1613,7 +1612,7 @@ impl<'hir> LoweringContext<'_, '_, 'hir> {
             parameters.push(new_parameter);
         }
 
-        let mkbody = |this: &mut LoweringContext<'_, '_, 'hir>| {
+        let mkbody = |this: &mut LoweringContext<'_, 'hir, R>| {
             // Create a block from the user's function body:
             let user_body = lower_body(this);