Put GenericsGenerationResults into DelegationResolution, cleanups

aerooneqq · aerooneqq · commit c2d7c9c3724c · 2026-06-29T15:03:18.000+03:00
diff --git a/compiler/rustc_ast_lowering/src/delegation/mod.rs b/compiler/rustc_ast_lowering/src/delegation/mod.rs
@@ -26,9 +26,9 @@
 //!
 //! Where `callee_path` is a path in delegation item e.g. `<Type as Trait>::name`.
 //! `sig_id` is a id of item from which the signature is inherited. It may be a delegation
-//! item id (`item_id`) in case of impl trait or path resolution id (`path_id`) otherwise.
+//! item id (`item_id`) in case of impl trait or path res id (`path_id`) otherwise.
 //!
-//! Since we do not have a proper way to obtain function type information by path resolution
+//! Since we do not have a proper way to obtain function type information by path res
 //! in AST, we mark each function parameter type as `InferDelegation` and inherit it during
 //! HIR ty lowering.
 //!
@@ -80,25 +80,26 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let span = self.lower_span(delegation.last_segment_span());
 
         let resolver = DelegationResolverForLowering(self);
-        let Ok((res, mut generics)) = resolver.resolve_delegation(delegation, span) else {
+        let Ok(mut res) = resolver.resolve_delegation(delegation, span) else {
             return self.generate_delegation_error(span, delegation);
         };
 
         self.add_attributes_if_needed(&res);
 
         let (body_id, call_expr_id, unused_target_expr) =
-            self.lower_delegation_body(delegation, &res, &mut generics);
+            self.lower_delegation_body(delegation, &mut res);
 
-        let decl = self.lower_delegation_decl(&res, &generics, call_expr_id, unused_target_expr);
+        let decl =
+            self.lower_delegation_decl(&res, &res.generics, call_expr_id, unused_target_expr);
 
         let sig = self.lower_delegation_sig(res.sig_id, decl, span);
 
         let ident = self.lower_ident(delegation.ident);
 
         let generics = self.arena.alloc(hir::Generics {
             has_where_clause_predicates: false,
-            params: self.arena.alloc_from_iter(generics.all_params()),
-            predicates: self.arena.alloc_from_iter(generics.all_predicates()),
+            params: self.arena.alloc_from_iter(res.generics.all_params()),
+            predicates: self.arena.alloc_from_iter(res.generics.all_predicates()),
             span,
             where_clause_span: span,
         });
@@ -112,21 +113,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_delegation_decl(
         &mut self,
-        resolution: &DelegationResolution<'hir>,
+        res: &DelegationResolution<'hir>,
         generics: &GenericsGenerationResults<'hir>,
         call_expr_id: HirId,
         unused_target_expr: bool,
     ) -> &'hir hir::FnDecl<'hir> {
-        let &DelegationResolution { source, call_path_node_id, span, .. } = resolution;
-        let ParamInfo { param_count, c_variadic, splatted } = resolution.param_info;
+        let &DelegationResolution { source, call_path_node_id, span, .. } = res;
+        let ParamInfo { param_count, c_variadic, splatted } = res.param_info;
 
         // The last parameter in C variadic functions is skipped in the signature,
         // like during regular lowering.
         let decl_param_count = param_count - c_variadic as usize;
         let inputs = self.arena.alloc_from_iter((0..decl_param_count).map(|arg| hir::Ty {
             hir_id: self.next_id(),
             kind: hir::TyKind::InferDelegation(hir::InferDelegation::Sig(
-                resolution.sig_id,
+                res.sig_id,
                 hir::InferDelegationSig::Input(arg),
             )),
             span,
@@ -135,7 +136,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let output = self.arena.alloc(hir::Ty {
             hir_id: self.next_id(),
             kind: hir::TyKind::InferDelegation(hir::InferDelegation::Sig(
-                resolution.sig_id,
+                res.sig_id,
                 hir::InferDelegationSig::Output(self.arena.alloc(hir::DelegationInfo {
                     call_expr_id,
                     call_path_res: self.get_resolution_id(call_path_node_id),
@@ -250,17 +251,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_delegation_body(
         &mut self,
         delegation: &Delegation,
-        resolution: &DelegationResolution<'hir>,
-        generics: &mut GenericsGenerationResults<'hir>,
+        res: &mut DelegationResolution<'hir>,
     ) -> (BodyId, HirId, bool) {
         let block = delegation.body.as_deref();
         let mut call_expr_id = HirId::INVALID;
         let mut unused_target_expr = false;
 
         let block_id = self.lower_body(|this| {
-            let &DelegationResolution {
-                param_info, span, should_generate_block, is_method, ..
-            } = resolution;
+            let &mut DelegationResolution {
+                param_info,
+                span,
+                should_generate_block,
+                is_method,
+                ..
+            } = res;
 
             let ParamInfo { param_count, .. } = param_info;
 
@@ -314,7 +318,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
 
             let (final_expr, hir_id) =
-                this.finalize_body_lowering(delegation, stmts, args, generics, resolution, span);
+                this.finalize_body_lowering(delegation, stmts, args, res, span);
 
             call_expr_id = hir_id;
 
@@ -331,8 +335,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         delegation: &Delegation,
         stmts: &'hir [hir::Stmt<'hir>],
         args: Vec<hir::Expr<'hir>>,
-        generics: &mut GenericsGenerationResults<'hir>,
-        resolution: &DelegationResolution<'hir>,
+        res: &mut DelegationResolution<'hir>,
         span: Span,
     ) -> (hir::Expr<'hir>, HirId) {
         let path = self.lower_qpath(
@@ -353,9 +356,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 new_path.segments = self.arena.alloc_from_iter(
                     new_path.segments.iter().enumerate().map(|(idx, segment)| {
                         if idx + 2 == len {
-                            self.process_segment(span, segment, &mut generics.parent)
+                            self.process_segment(span, segment, &mut res.generics.parent)
                         } else if idx + 1 == len {
-                            self.process_segment(span, segment, &mut generics.child)
+                            self.process_segment(span, segment, &mut res.generics.child)
                         } else {
                             segment.clone()
                         }
@@ -364,9 +367,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                 // Explicitly create `Self` self-type in case of infers or static
                 // free-to-trait reuses.
-                let ty = match generics.self_ty_propagation_kind {
+                let ty = match res.generics.self_ty_propagation_kind {
                     Some(hir::DelegationSelfTyPropagationKind::SelfParam) => {
-                        let self_param = generics.parent.generics.find_self_param();
+                        let self_param = res.generics.parent.generics.find_self_param();
                         let path = self.create_generic_arg_path(self_param);
                         let kind = hir::TyKind::Path(path);
 
@@ -386,7 +389,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         };
 
         if let Some(hir::DelegationSelfTyPropagationKind::SelfTy(id)) =
-            generics.self_ty_propagation_kind.as_mut()
+            res.generics.self_ty_propagation_kind.as_mut()
         {
             *id = match new_path {
                 hir::QPath::Resolved(ty, _) => {
@@ -401,7 +404,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let args = self.arena.alloc_from_iter(args);
         let call = self.mk_expr(hir::ExprKind::Call(callee_path, args), span);
 
-        let expr = if let Some(new_type) = resolution.parent_newtype {
+        let expr = if let Some(new_type) = res.parent_newtype {
             let variant = new_type.variant(VariantIdx::ZERO);
             let res = Res::Def(DefKind::Fn, variant.ctor.expect("must have constructor").1);
 
diff --git a/compiler/rustc_ast_lowering/src/delegation/resolution.rs b/compiler/rustc_ast_lowering/src/delegation/resolution.rs
@@ -81,6 +81,7 @@ pub(super) struct DelegationResolution<'tcx> {
     pub(super) call_path_node_id: NodeId,
     pub(super) source: DelegationSource,
     pub(super) parent_newtype: Option<ty::AdtDef<'tcx>>,
+    pub(super) generics: GenericsGenerationResults<'tcx>,
 }
 
 pub(super) struct DelegationResolverForLowering<'a, T>(pub(super) &'a mut T);
@@ -90,22 +91,25 @@ impl<'tcx, T: LoweringContextForResolution<'tcx>> DelegationResolverForLowering<
         &self,
         delegation: &Delegation,
         span: Span,
-    ) -> Result<(DelegationResolution<'tcx>, GenericsGenerationResults<'tcx>), ErrorGuaranteed>
-    {
+    ) -> Result<DelegationResolution<'tcx>, ErrorGuaranteed> {
         let tcx = self.0.tcx();
         let def_id = self.0.owner_id();
 
-        let Some(info) = tcx.resolutions(()).delegation_infos.get(&def_id) else {
-            return Err(tcx.dcx().span_delayed_bug(
-                span,
-                format!("delegation resolution record was not found for {:?}", def_id),
-            ));
-        };
-
         // Delegation can be missing from the `delegations_resolutions` table
         // in illegal places such as function bodies in extern blocks (see #151356).
-        let sig_id =
-            info.resolution_id.and_then(|id| self.check_for_cycles(id, span).map(|_| id))?;
+        let sig_id = tcx
+            .resolutions(())
+            .delegation_infos
+            .get(&def_id)
+            .map(|info| {
+                info.resolution_id.and_then(|id| self.check_for_cycles(id, span).map(|_| id))
+            })
+            .unwrap_or_else(|| {
+                Err(tcx.dcx().span_delayed_bug(
+                    span,
+                    format!("delegation resolution record was not found for {:?}", def_id),
+                ))
+            })?;
 
         let is_method = match tcx.def_kind(sig_id) {
             DefKind::Fn => false,
@@ -120,24 +124,23 @@ impl<'tcx, T: LoweringContextForResolution<'tcx>> DelegationResolverForLowering<
         // FIXME(splat): use `sig.splatted()` once FnSig has it
         let param_info = ParamInfo { param_count, c_variadic: sig.c_variadic(), splatted: None };
 
-        self.check_block_soundness(delegation, sig_id, is_method, param_count)?;
+        let should_generate_block =
+            self.check_block_soundness(delegation, sig_id, is_method, param_count)?;
 
         let parent_newtype = self.should_wrap_return_value(delegation);
+        let generics = self.resolve_generics(delegation, sig_id);
 
-        let resolution = DelegationResolution {
-            should_generate_block: self.should_generate_block(delegation, sig_id, is_method),
+        Ok(DelegationResolution {
+            should_generate_block,
             is_method,
             param_info,
             span,
             sig_id,
             source: delegation.source,
             call_path_node_id: delegation.id,
             parent_newtype,
-        };
-
-        let generics = self.resolve_generics(delegation, sig_id);
-
-        Ok((resolution, generics))
+            generics,
+        })
     }
 
     fn check_for_cycles(&self, mut def_id: DefId, span: Span) -> Result<(), ErrorGuaranteed> {
@@ -173,11 +176,13 @@ impl<'tcx, T: LoweringContextForResolution<'tcx>> DelegationResolverForLowering<
         sig_id: DefId,
         is_method: bool,
         param_count: usize,
-    ) -> Result<(), ErrorGuaranteed> {
-        let Some(block) = delegation.body.as_ref() else { return Ok(()) };
-
+    ) -> Result<bool, ErrorGuaranteed> {
         let tcx = self.0.tcx();
-        let should_generate_block = self.should_generate_block(delegation, sig_id, is_method);
+        let should_generate_block = is_method
+            || matches!(tcx.def_kind(sig_id), DefKind::Fn)
+            || matches!(delegation.source, DelegationSource::Single);
+
+        let Some(block) = delegation.body.as_ref() else { return Ok(should_generate_block) };
 
         // Report an error if user has explicitly specified delegation's target expression
         // in a single delegation when reused function has no params.
@@ -208,23 +213,12 @@ impl<'tcx, T: LoweringContextForResolution<'tcx>> DelegationResolverForLowering<
         // If there are definitions inside and we can't delete target expression, then report an error.
         // FIXME(fn_delegation): support deletion of target expression with defs inside.
         if should_generate_block || !contains_defs {
-            Ok(())
+            Ok(should_generate_block)
         } else {
             Err(tcx.dcx().emit_err(DelegationAttemptedBlockWithDefsDeletion { span: block.span }))
         }
     }
 
-    fn should_generate_block(
-        &self,
-        delegation: &Delegation,
-        sig_id: DefId,
-        is_method: bool,
-    ) -> bool {
-        is_method
-            || matches!(self.0.tcx().def_kind(sig_id), DefKind::Fn)
-            || matches!(delegation.source, DelegationSource::Single)
-    }
-
     fn should_wrap_return_value(&self, delegation: &Delegation) -> Option<ty::AdtDef<'tcx>> {
         let tcx = self.0.tcx();
         let parent = tcx.local_parent(self.0.owner_id());
