Refactor AST -> HIR delegation lowering

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation/attributes.rs

@@ -0,0 +1,86 @@
+use rustc_hir::attrs::{AttributeKind, InlineAttr};
+use rustc_hir::{self as hir};
+use rustc_span::Span;
+use rustc_span::def_id::DefId;
+
+use crate::LoweringContext;
+use crate::delegation::DelegationResolution;
+
+struct AdditionInfo {
+    pub equals: fn(&hir::Attribute) -> bool,
+    pub kind: AdditionKind,
+}
+
+enum AdditionKind {
+    Default { factory: fn(Span) -> hir::Attribute },
+    Inherit { factory: fn(Span, &hir::Attribute) -> hir::Attribute },
+}
+
+static ADDITIONS: &[AdditionInfo] = &[
+    AdditionInfo {
+        equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::MustUse { .. })),
+        kind: AdditionKind::Inherit {
+            factory: |span, original_attr| {
+                let reason = match original_attr {
+                    hir::Attribute::Parsed(AttributeKind::MustUse { reason, .. }) => *reason,
+                    _ => None,
+                };
+
+                hir::Attribute::Parsed(AttributeKind::MustUse { span, reason })
+            },
+        },
+    },
+    AdditionInfo {
+        equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::Inline(..))),
+        kind: AdditionKind::Default {
+            factory: |span| hir::Attribute::Parsed(AttributeKind::Inline(InlineAttr::Hint, span)),
+        },
+    },
+];
+
+impl<'hir> LoweringContext<'_, 'hir> {
+    pub(super) fn add_attributes_if_needed(&mut self, resolution: &DelegationResolution<'hir>) {
+        let &DelegationResolution { span, sig_id, .. } = resolution;
+
+        let new_attrs = self.create_new_attributes(span, sig_id, self.attrs.get(&PARENT_ID));
+
+        const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
+
+        if !new_attrs.is_empty() {
+            let new_attrs = match self.attrs.get(&PARENT_ID) {
+                Some(existing_attrs) => self.arena.alloc_from_iter(
+                    existing_attrs.iter().map(|a| a.clone()).chain(new_attrs.into_iter()),
+                ),
+                None => self.arena.alloc_from_iter(new_attrs.into_iter()),
+            };
+
+            self.attrs.insert(PARENT_ID, new_attrs);
+        }
+    }
+
+    fn create_new_attributes(
+        &self,
+        span: Span,
+        sig_id: DefId,
+        existing_attrs: Option<&&[hir::Attribute]>,
+    ) -> Vec<hir::Attribute> {
+        ADDITIONS
+            .iter()
+            .filter_map(|addition_info| {
+                existing_attrs
+                    .filter(|attrs| attrs.iter().any(|a| (addition_info.equals)(a)))
+                    .and_then(|_| match addition_info.kind {
+                        AdditionKind::Default { factory } => Some(factory(span)),
+                        AdditionKind::Inherit { factory, .. } =>
+                        {
+                            #[allow(deprecated)]
+                            self.tcx
+                                .get_all_attrs(sig_id)
+                                .iter()
+                                .find_map(|a| (addition_info.equals)(a).then(|| factory(span, a)))
+                        }
+                    })
+            })
+            .collect::<Vec<_>>()
+    }
+}

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -4,12 +4,14 @@ use rustc_ast::*;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
-use rustc_middle::ty::GenericParamDefKind;
+use rustc_middle::ty::{GenericParamDefKind, TyCtxt};
 use rustc_middle::{bug, ty};
 use rustc_span::symbol::kw;
 use rustc_span::{Ident, Span, sym};
 
 use crate::LoweringContext;
+use crate::delegation::DelegationResolverForLowering;
+use crate::delegation::resolution::LoweringContextForResolution;
 use crate::diagnostics::DelegationInfersMismatch;
 
 #[derive(Debug, Clone, Copy)]
@@ -230,46 +232,15 @@ impl<'hir> GenericsGenerationResult<'hir> {
     }
 }
 
-impl<'hir> GenericsGenerationResults<'hir> {
-    pub(super) fn all_params(&self) -> impl Iterator<Item = hir::GenericParam<'hir>> {
-        let parent = self.parent.generics.hir_generics_or_empty().params;
-        let child = self.child.generics.hir_generics_or_empty().params;
-
-        // Order generics, first we have parent and child lifetimes,
-        // then parent and child types and consts.
-        // `generics_of` in `rustc_hir_analysis` will order them anyway,
-        // however we want the order to be consistent in HIR too.
-        parent
-            .iter()
-            .filter(|p| p.is_lifetime())
-            .chain(child.iter().filter(|p| p.is_lifetime()))
-            .chain(parent.iter().filter(|p| !p.is_lifetime()))
-            .chain(child.iter().filter(|p| !p.is_lifetime()))
-            .copied()
-    }
-
-    /// As we add hack predicates(`'a: 'a`) for all lifetimes (see `uplift_delegation_generic_params`
-    /// 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(&self) -> impl Iterator<Item = hir::WherePredicate<'hir>> {
-        self.parent
-            .generics
-            .hir_generics_or_empty()
-            .predicates
-            .into_iter()
-            .chain(self.child.generics.hir_generics_or_empty().predicates)
-            .copied()
-    }
-}
-
-impl<'hir> LoweringContext<'_, 'hir> {
-    pub(super) fn uplift_delegation_generics(
-        &mut self,
+impl<'hir, T: LoweringContextForResolution<'hir>> DelegationResolverForLowering<'_, T> {
+    pub(super) fn resolve_generics(
+        &self,
         delegation: &Delegation,
         sig_id: DefId,
     ) -> GenericsGenerationResults<'hir> {
-        let delegation_parent_kind = self.tcx.def_kind(self.tcx.local_parent(self.owner.def_id));
+        let tcx = self.0.tcx();
+
+        let delegation_parent_kind = tcx.def_kind(tcx.local_parent(self.0.owner_id()));
 
         let segments = &delegation.path.segments;
         let len = segments.len();
@@ -279,7 +250,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
             let Some(args) = segment.args.as_ref() else { return None };
             let GenericArgs::AngleBracketed(args) = args else {
-                self.tcx.dcx().span_delayed_bug(
+                tcx.dcx().span_delayed_bug(
                     segment.span(),
                     "expected angle-bracketed generic args in delegation segment",
                 );
@@ -293,7 +264,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             (!args.args.is_empty()).then(|| args)
         };
 
-        let sig_params = &self.tcx.generics_of(sig_id).own_params[..];
+        let sig_params = &tcx.generics_of(sig_id).own_params[..];
 
         // If we are in trait impl always generate function whose generics matches
         // those that are defined in trait.
@@ -314,8 +285,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let delegation_in_free_ctx =
             !matches!(delegation_parent_kind, DefKind::Trait | DefKind::Impl { .. });
 
-        let sig_parent = self.tcx.parent(sig_id);
-        let sig_in_trait = matches!(self.tcx.def_kind(sig_parent), DefKind::Trait);
+        let sig_parent = tcx.parent(sig_id);
+        let sig_in_trait = matches!(tcx.def_kind(sig_parent), DefKind::Trait);
         let free_to_trait_delegation = delegation_in_free_ctx && sig_in_trait;
 
         let qself_is_infer =
@@ -326,16 +297,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let generate_self = free_to_trait_delegation && (qself_is_none || qself_is_infer);
 
         let can_add_generics_to_parent = len >= 2
-            && self.get_resolution_id(segments[len - 2].id).is_some_and(|def_id| {
-                matches!(self.tcx.def_kind(def_id), DefKind::Trait | DefKind::TraitAlias)
+            && self.0.get_resolution_id(segments[len - 2].id).is_some_and(|def_id| {
+                matches!(tcx.def_kind(def_id), DefKind::Trait | DefKind::TraitAlias)
             });
 
         let parent_generics = if can_add_generics_to_parent {
-            let sig_parent_params = &self.tcx.generics_of(sig_parent).own_params;
+            let sig_parent_params = &tcx.generics_of(sig_parent).own_params;
 
             if let Some(args) = get_user_args(len - 2) {
                 DelegationGenerics {
-                    data: self.create_slots_from_args(
+                    data: Self::create_slots_from_args(
+                        tcx,
                         args,
                         &sig_parent_params[usize::from(!generate_self)..],
                         generate_self,
@@ -359,7 +331,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 sig_params.iter().position(|p| p.kind.is_synthetic()).unwrap_or(sig_params.len());
 
             let mut slots =
-                self.create_slots_from_args(args, &sig_params[..synth_params_index], false);
+                Self::create_slots_from_args(tcx, args, &sig_params[..synth_params_index], false);
 
             for synth_param in &sig_params[synth_params_index..] {
                 slots.push(GenericArgSlot::Generate(synth_param, None));
@@ -396,7 +368,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// infers than generic params then we will not process all infers thus not generating
     /// more generic params then needed (anyway it is an error).
     fn create_slots_from_args(
-        &self,
+        tcx: TyCtxt<'_>,
         args: &AngleBracketedArgs,
         params: &'hir [ty::GenericParamDef],
         add_first_self: bool,
@@ -437,11 +409,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     (kw::Underscore, kw::UnderscoreLifetime)
                 };
 
-                self.tcx.dcx().emit_err(DelegationInfersMismatch {
-                    span: arg.span(),
-                    actual,
-                    expected,
-                });
+                tcx.dcx().emit_err(DelegationInfersMismatch { span: arg.span(), actual, expected });
             }
 
             slots.push(match is_infer {
@@ -452,7 +420,42 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         slots
     }
+}
+
+impl<'hir> GenericsGenerationResults<'hir> {
+    pub(super) fn all_params(&self) -> impl Iterator<Item = hir::GenericParam<'hir>> {
+        let parent = self.parent.generics.hir_generics_or_empty().params;
+        let child = self.child.generics.hir_generics_or_empty().params;
+
+        // Order generics, first we have parent and child lifetimes,
+        // then parent and child types and consts.
+        // `generics_of` in `rustc_hir_analysis` will order them anyway,
+        // however we want the order to be consistent in HIR too.
+        parent
+            .iter()
+            .filter(|p| p.is_lifetime())
+            .chain(child.iter().filter(|p| p.is_lifetime()))
+            .chain(parent.iter().filter(|p| !p.is_lifetime()))
+            .chain(child.iter().filter(|p| !p.is_lifetime()))
+            .copied()
+    }
+
+    /// As we add hack predicates(`'a: 'a`) for all lifetimes (see `uplift_delegation_generic_params`
+    /// 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(&self) -> impl Iterator<Item = hir::WherePredicate<'hir>> {
+        self.parent
+            .generics
+            .hir_generics_or_empty()
+            .predicates
+            .into_iter()
+            .chain(self.child.generics.hir_generics_or_empty().predicates)
+            .copied()
+    }
+}
 
+impl<'hir> LoweringContext<'_, 'hir> {
     fn uplift_delegation_generic_params(
         &mut self,
         span: Span,