Refactorings: code cleanup

aerooneqq · aerooneqq · commit aa4e4e84545e · 2026-02-05T18:11:30.000+03:00
diff --git a/compiler/rustc_ast_lowering/src/delegation/delegation.rs b/compiler/rustc_ast_lowering/src/delegation/delegation.rs
@@ -638,13 +638,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
             // FIXME(fn_delegation): proper support for parent generics propagation
             // in method call scenario.
-            let segment = self.arena.alloc(self.process_segment(
-                item_id,
-                span,
-                &segment,
-                &mut generics.child,
-                false,
-            ));
+            let segment = self.process_segment(item_id, span, &segment, &mut generics.child, false);
+            let segment = self.arena.alloc(segment);
 
             self.arena.alloc(hir::Expr {
                 hir_id: self.next_id(),
@@ -685,16 +680,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                     hir::QPath::Resolved(ty, self.arena.alloc(new_path))
                 }
-                hir::QPath::TypeRelative(ty, segment) => hir::QPath::TypeRelative(
-                    ty,
-                    self.arena.alloc(self.process_segment(
-                        item_id,
-                        span,
-                        segment,
-                        &mut generics.child,
-                        false,
-                    )),
-                ),
+                hir::QPath::TypeRelative(ty, segment) => {
+                    let segment =
+                        self.process_segment(item_id, span, segment, &mut generics.child, false);
+
+                    hir::QPath::TypeRelative(ty, self.arena.alloc(segment))
+                }
             };
 
             let callee_path = self.arena.alloc(self.mk_expr(hir::ExprKind::Path(new_path), span));
diff --git a/compiler/rustc_ast_lowering/src/delegation/generics.rs b/compiler/rustc_ast_lowering/src/delegation/generics.rs
@@ -81,7 +81,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         generics: &DelegationGenerics<Generics>,
     ) -> DelegationGenerics<&'hir hir::Generics<'hir>> {
         let mut process_params = |generics: &Option<Generics>| {
-            generics.as_ref().map(|g| self.process_generic_params(item_id, span, g.params.clone()))
+            generics
+                .as_ref()
+                .map(|g| self.lower_delegation_generic_params(item_id, span, g.params.clone()))
         };
 
         match generics {
@@ -95,7 +97,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn process_generic_params(
+    fn lower_delegation_generic_params(
         &mut self,
         item_id: NodeId,
         span: Span,
@@ -357,43 +359,43 @@ impl<'hir> LoweringContext<'_, 'hir> {
         add_self: bool,
         user_specified: bool,
     ) -> Option<Generics> {
-        id.map(|id| {
-            let mut generics = if user_specified {
-                Some(Generics::default())
-            } else {
-                if let Some(local_id) = id.as_local() {
-                    if let Some(AstOwner::Item(item)) = self.ast_accessor.get(local_id)
-                        && matches!(item.kind, ItemKind::Trait(..))
-                    {
-                        item.opt_generics().cloned()
-                    } else {
-                        None
-                    }
+        let id = if let Some(id) = id { id } else { return None };
+
+        // If args are user-specified we still maybe need to add self
+        let mut generics = if user_specified {
+            None
+        } else {
+            if let Some(local_id) = id.as_local() {
+                if let Some(AstOwner::Item(item)) = self.ast_accessor.get(local_id)
+                    && matches!(item.kind, ItemKind::Trait(..))
+                {
+                    item.opt_generics().cloned()
                 } else {
-                    self.get_external_generics(id, true)
+                    None
                 }
-            };
-
-            if add_self {
-                generics = Some(generics.unwrap_or(Generics::default()));
-
-                generics.as_mut().unwrap().params.insert(
-                    0,
-                    GenericParam {
-                        id: self.next_node_id(),
-                        ident: Ident::new(kw::SelfUpper, DUMMY_SP),
-                        attrs: Default::default(),
-                        bounds: vec![],
-                        is_placeholder: false,
-                        kind: GenericParamKind::Type { default: None },
-                        colon_span: None,
-                    },
-                );
+            } else {
+                self.get_external_generics(id, true)
             }
+        };
 
-            generics
-        })
-        .flatten()
+        if add_self {
+            generics = Some(generics.unwrap_or(Generics::default()));
+
+            generics.as_mut().unwrap().params.insert(
+                0,
+                GenericParam {
+                    id: self.next_node_id(),
+                    ident: Ident::new(kw::SelfUpper, DUMMY_SP),
+                    attrs: Default::default(),
+                    bounds: vec![],
+                    is_placeholder: false,
+                    kind: GenericParamKind::Type { default: None },
+                    colon_span: None,
+                },
+            );
+        }
+
+        generics
     }
 }
 
@@ -405,13 +407,13 @@ pub(super) enum HirOrAstGenerics<'hir> {
 impl<'hir> HirOrAstGenerics<'hir> {
     pub(super) fn into_hir_generics(
         &mut self,
-        this: &mut LoweringContext<'_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir>,
         item_id: NodeId,
         span: Span,
     ) -> &mut Self {
         match self {
             HirOrAstGenerics::Ast(delegation_generics) => {
-                *self = Self::Hir(this.lower_ast_generics(item_id, span, delegation_generics));
+                *self = Self::Hir(ctx.lower_ast_generics(item_id, span, delegation_generics));
             }
             HirOrAstGenerics::Hir(_) => {}
         }
@@ -434,20 +436,17 @@ impl<'hir> HirOrAstGenerics<'hir> {
 
     pub(super) fn into_generic_args(
         &self,
-        this: &mut LoweringContext<'_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir>,
         add_lifetimes: bool,
     ) -> Option<&'hir hir::GenericArgs<'hir>> {
         match self {
             HirOrAstGenerics::Ast(_) => None,
             HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => None,
                 DelegationGenerics::Default(generics)
-                | DelegationGenerics::SelfAndUserSpecified(generics) => match generics {
-                    Some(generics) => {
-                        Some(this.create_generics_args_from_params(generics.params, add_lifetimes))
-                    }
-                    None => None,
-                },
+                | DelegationGenerics::SelfAndUserSpecified(generics) => generics.map(|generics| {
+                    ctx.create_generics_args_from_params(generics.params, add_lifetimes)
+                }),
             },
         }
     }
@@ -481,19 +480,19 @@ impl<'hir> GenericsGenerationResults<'hir> {
         &mut self,
         item_id: NodeId,
         span: Span,
-        this: &mut LoweringContext<'_, 'hir>,
+        ctx: &mut LoweringContext<'_, 'hir>,
     ) -> impl Iterator<Item = hir::GenericParam<'hir>> {
         let parent = self
             .parent
             .generics
-            .into_hir_generics(this, item_id, span)
+            .into_hir_generics(ctx, item_id, span)
             .hir_generics_or_empty()
             .params;
 
         let child = self
             .child
             .generics
-            .into_hir_generics(this, item_id, span)
+            .into_hir_generics(ctx, item_id, span)
             .hir_generics_or_empty()
             .params;
 
diff --git a/compiler/rustc_hir_analysis/src/delegation.rs b/compiler/rustc_hir_analysis/src/delegation.rs
@@ -219,22 +219,19 @@ fn get_delegation_parent_args_count_without_self<'tcx>(
     let delegation_parent_args_count = tcx.generics_of(delegation_id).parent_count;
 
     match get_caller_and_callee_kind(tcx, delegation_id, sig_id) {
-        (FnKind::Free, FnKind::Free) | (FnKind::Free, FnKind::AssocTrait) => 0,
+        (FnKind::Free, FnKind::Free)
+        | (FnKind::Free, FnKind::AssocTrait)
+        | (FnKind::AssocTraitImpl, FnKind::AssocTrait) => 0,
 
-        (FnKind::AssocInherentImpl, FnKind::Free) => {
+        (FnKind::AssocInherentImpl, FnKind::Free)
+        | (FnKind::AssocInherentImpl, FnKind::AssocTrait) => {
             delegation_parent_args_count /* No Self in AssocInherentImpl */
         }
 
         (FnKind::AssocTrait, FnKind::Free) | (FnKind::AssocTrait, FnKind::AssocTrait) => {
             delegation_parent_args_count - 1 /* Without Self */
         }
 
-        (FnKind::AssocTraitImpl, FnKind::AssocTrait) => 0,
-
-        (FnKind::AssocInherentImpl, FnKind::AssocTrait) => {
-            delegation_parent_args_count /* No Self in AssocInherentImpl */
-        }
-
         unsupported_caller_callee_kinds!() => unreachable!(),
     }
 }
@@ -304,22 +301,36 @@ pub(crate) fn get_delegation_self_ty<'tcx>(
         }
 
         (FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
-            let parent = tcx.parent(delegation_id.into());
-            let parent_args = tcx.impl_trait_header(parent).trait_ref.instantiate_identity().args;
-            parent_args.first().map(|a| a.as_type()).flatten()
+            create_trait_impl_to_trait_parent_args(tcx, delegation_id)
+                .first()
+                .map(|a| a.as_type())
+                .flatten()
         }
 
         (FnKind::AssocInherentImpl, FnKind::AssocTrait) => {
-            let parent = tcx.parent(delegation_id.into());
-            let self_ty = tcx.type_of(parent).instantiate_identity();
-
-            Some(self_ty)
+            Some(create_inherent_impl_to_trait_self_ty(tcx, delegation_id))
         }
 
         unsupported_caller_callee_kinds!() => unreachable!(),
     }
 }
 
+fn create_trait_impl_to_trait_parent_args<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    delegation_id: LocalDefId,
+) -> ty::GenericArgsRef<'tcx> {
+    let parent = tcx.parent(delegation_id.into());
+    tcx.impl_trait_header(parent).trait_ref.instantiate_identity().args
+}
+
+fn create_inherent_impl_to_trait_self_ty<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    delegation_id: LocalDefId,
+) -> Ty<'tcx> {
+    let parent = tcx.parent(delegation_id.into());
+    tcx.type_of(parent).instantiate_identity()
+}
+
 /// Creates generic arguments for further delegation signature and predicates instantiation.
 /// Arguments can be user-specified (in this case they are in `parent_args` and `child_args`)
 /// or propagated. User can specify either both `parent_args` and `child_args`, one of them or none,
@@ -358,22 +369,18 @@ fn create_generic_args<'tcx>(
         | (FnKind::AssocTrait, FnKind::AssocTrait) => delegation_args,
 
         (FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
-            let parent = tcx.parent(delegation_id.into());
             // Special case, as user specifies Trait args in impl trait header, we want to treat
             // them as parent args.
-            parent_args = tcx.impl_trait_header(parent).trait_ref.instantiate_identity().args;
-
+            parent_args = create_trait_impl_to_trait_parent_args(tcx, delegation_id);
             tcx.mk_args(&delegation_args[delegation_parent_args_count..])
         }
 
         (FnKind::AssocInherentImpl, FnKind::AssocTrait) => {
-            let parent = tcx.parent(delegation_id.into());
-            let self_ty = tcx.type_of(parent).instantiate_identity();
-            let generic_self_ty = ty::GenericArg::from(self_ty);
-
-            let args_iter = std::iter::once(generic_self_ty).chain(delegation_args.iter());
+            let self_ty = create_inherent_impl_to_trait_self_ty(tcx, delegation_id);
 
-            tcx.mk_args_from_iter(args_iter)
+            tcx.mk_args_from_iter(
+                std::iter::once(ty::GenericArg::from(self_ty)).chain(delegation_args.iter()),
+            )
         }
 
         unsupported_caller_callee_kinds!() => unreachable!(),
