Always propagate generic params in trait impl case

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

@@ -724,10 +724,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         result: &mut GenericsGenerationResult<'hir>,
         add_lifetimes: bool,
     ) -> hir::PathSegment<'hir> {
-        // The second condition is needed when there is SelfAndUserSpecified case,
+        let details = result.generics.get_args_propagation_details();
+
+        // The first condition is needed when there is SelfAndUserSpecified case,
         // we don't want to propagate generics params in this situation.
-        let segment = if result.can_propagate()
-            && !result.generics.is_user_specified()
+        let segment = if details.should_propagate
             && let Some(args) = result
                 .generics
                 .into_hir_generics(self, item_id, span)
@@ -738,7 +739,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             segment.clone()
         };
 
-        if result.generics.is_user_specified() {
+        if details.use_args_in_sig_inheritance {
             result.args_segment_id = Some(segment.hir_id);
         }
 

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -20,6 +20,10 @@ pub(super) enum DelegationGenerics<T> {
     /// In free-to-trait reuse, when user specified args for trait `reuse Trait::<i32>::foo;`
     /// in this case we need to both generate `Self` and process user args.
     SelfAndUserSpecified(Option<T>),
+    /// In delegations from trait impl to other entities like free functions or trait functions,
+    /// we want to generate a function whose generics matches generics of signature function
+    /// in trait.
+    TraitImpl(Option<T>, bool /* Has user-specified args */),
 }
 
 /// Used for storing either AST generics or their lowered HIR version. Firstly we obtain
@@ -38,28 +42,39 @@ pub(super) enum HirOrAstGenerics<'hir> {
     Hir(DelegationGenerics<&'hir hir::Generics<'hir>>),
 }
 
-pub(super) enum PropagationKind {
-    Allowed,
-    Forbidden,
-}
-
 pub(super) struct GenericsGenerationResult<'hir> {
     pub(super) generics: HirOrAstGenerics<'hir>,
     pub(super) args_segment_id: Option<HirId>,
-    pub(super) propagation_kind: PropagationKind,
 }
 
 pub(super) struct GenericsGenerationResults<'hir> {
     pub(super) parent: GenericsGenerationResult<'hir>,
     pub(super) child: GenericsGenerationResult<'hir>,
 }
 
+pub(super) struct GenericArgsPropagationDetails {
+    pub(super) should_propagate: bool,
+    pub(super) use_args_in_sig_inheritance: bool,
+}
+
 impl<T> DelegationGenerics<T> {
-    fn is_user_specified(&self) -> bool {
-        matches!(
-            self,
-            DelegationGenerics::UserSpecified | DelegationGenerics::SelfAndUserSpecified { .. }
-        )
+    fn get_args_propagation_details(&self) -> GenericArgsPropagationDetails {
+        match self {
+            DelegationGenerics::UserSpecified | DelegationGenerics::SelfAndUserSpecified { .. } => {
+                GenericArgsPropagationDetails {
+                    should_propagate: false,
+                    use_args_in_sig_inheritance: true,
+                }
+            }
+            DelegationGenerics::TraitImpl(_, user_specified) => GenericArgsPropagationDetails {
+                should_propagate: !*user_specified,
+                use_args_in_sig_inheritance: false,
+            },
+            DelegationGenerics::Default(_) => GenericArgsPropagationDetails {
+                should_propagate: true,
+                use_args_in_sig_inheritance: false,
+            },
+        }
     }
 }
 
@@ -83,6 +98,12 @@ impl<'hir> HirOrAstGenerics<'hir> {
                 DelegationGenerics::SelfAndUserSpecified(generics) => {
                     DelegationGenerics::SelfAndUserSpecified(generics.as_mut().map(process_params))
                 }
+                DelegationGenerics::TraitImpl(generics, user_specified) => {
+                    DelegationGenerics::TraitImpl(
+                        generics.as_mut().map(process_params),
+                        *user_specified,
+                    )
+                }
             };
 
             *self = HirOrAstGenerics::Hir(hir_generics);
@@ -97,7 +118,8 @@ impl<'hir> HirOrAstGenerics<'hir> {
             HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => hir::Generics::empty(),
                 DelegationGenerics::Default(generics)
-                | DelegationGenerics::SelfAndUserSpecified(generics) => {
+                | DelegationGenerics::SelfAndUserSpecified(generics)
+                | DelegationGenerics::TraitImpl(generics, _) => {
                     generics.unwrap_or(hir::Generics::empty())
                 }
             },
@@ -117,36 +139,29 @@ impl<'hir> HirOrAstGenerics<'hir> {
             HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => None,
                 DelegationGenerics::Default(generics)
-                | DelegationGenerics::SelfAndUserSpecified(generics) => generics.map(|generics| {
+                | DelegationGenerics::SelfAndUserSpecified(generics)
+                | DelegationGenerics::TraitImpl(generics, _) => generics.map(|generics| {
                     ctx.create_generics_args_from_params(generics.params, add_lifetimes, span)
                 }),
             },
         }
     }
 
-    pub(super) fn is_user_specified(&self) -> bool {
+    pub(super) fn get_args_propagation_details(&self) -> GenericArgsPropagationDetails {
         match self {
-            HirOrAstGenerics::Ast(ast_generics) => ast_generics.is_user_specified(),
-            HirOrAstGenerics::Hir(hir_generics) => hir_generics.is_user_specified(),
+            HirOrAstGenerics::Ast(ast_generics) => ast_generics.get_args_propagation_details(),
+            HirOrAstGenerics::Hir(hir_generics) => hir_generics.get_args_propagation_details(),
         }
     }
 }
 
 impl<'a> GenericsGenerationResult<'a> {
-    fn new(
-        generics: DelegationGenerics<Generics>,
-        propagation_kind: PropagationKind,
-    ) -> GenericsGenerationResult<'a> {
+    fn new(generics: DelegationGenerics<Generics>) -> GenericsGenerationResult<'a> {
         GenericsGenerationResult {
             generics: HirOrAstGenerics::Ast(generics),
             args_segment_id: None,
-            propagation_kind,
         }
     }
-
-    pub(super) fn can_propagate(&self) -> bool {
-        matches!(self.propagation_kind, PropagationKind::Allowed)
-    }
 }
 
 impl<'hir> GenericsGenerationResults<'hir> {
@@ -161,8 +176,6 @@ impl<'hir> GenericsGenerationResults<'hir> {
         // method call will be supported (if HIR generics were not obtained
         // then it means that we did not propagated them, thus we do not need
         // to generate params).
-        // FIXME(fn_delegation): in impl trait case we still need to generate
-        // generic params, so this should be reworked.
         let parent = self
             .parent
             .generics
@@ -205,8 +218,6 @@ impl<'hir> GenericsGenerationResults<'hir> {
         // method call will be supported (if HIR generics were not obtained
         // then it means that we did not propagated them, thus we do not need
         // to generate predicates).
-        // FIXME(fn_delegation): in impl trait case we still need to generate
-        // generic params, so this should be reworked.
         self.parent
             .generics
             .into_hir_generics(ctx, item_id, span)
@@ -236,29 +247,20 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let delegation_parent_kind =
             self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id)));
 
+        let segments = &delegation.path.segments;
+        let len = segments.len();
+        let child_user_specified = segments[len - 1].args.is_some();
+
         // If we are in impl trait always generate function whose generics matches
         // those that are defined in trait.
         if matches!(delegation_parent_kind, DefKind::Impl { of_trait: true }) {
             // Considering parent generics, during signature inheritance
             // we will take those args that are in impl trait header trait ref.
-            let parent = GenericsGenerationResult::new(
-                DelegationGenerics::Default(None),
-                PropagationKind::Forbidden,
-            );
+            let parent = GenericsGenerationResult::new(DelegationGenerics::Default(None));
 
-            // Check if we can propagate generics: now we do it only if delegation
-            // path resolution matches the signature.
-            // FIXME(fn_delegation): more advanced checks for propagation,
-            // i.e., comparing generics of signature and `res` fn.
-            let res = self.get_resolution_id(delegation.id);
-            let prop_kind = if res.is_some_and(|def_id| def_id == root_fn_id) {
-                PropagationKind::Allowed
-            } else {
-                PropagationKind::Forbidden
-            };
-
-            let child = DelegationGenerics::Default(self.get_fn_like_generics(root_fn_id, span));
-            let child = GenericsGenerationResult::new(child, prop_kind);
+            let generics = self.get_fn_like_generics(root_fn_id, span);
+            let child = DelegationGenerics::TraitImpl(generics, child_user_specified);
+            let child = GenericsGenerationResult::new(child);
 
             return GenericsGenerationResults { parent, child };
         }
@@ -280,9 +282,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
             )
         };
 
-        let segments = &delegation.path.segments;
-        let len = segments.len();
-
         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)
@@ -302,15 +301,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
             DelegationGenerics::Default(None)
         };
 
-        let child_generics = if segments[len - 1].args.is_some() {
+        let child_generics = if child_user_specified {
             DelegationGenerics::UserSpecified
         } else {
             DelegationGenerics::Default(self.get_fn_like_generics(root_fn_id, span))
         };
 
         GenericsGenerationResults {
-            parent: GenericsGenerationResult::new(parent_generics, PropagationKind::Allowed),
-            child: GenericsGenerationResult::new(child_generics, PropagationKind::Allowed),
+            parent: GenericsGenerationResult::new(parent_generics),
+            child: GenericsGenerationResult::new(child_generics),
         }
     }
 

compiler/rustc_hir_analysis/src/delegation.rs

@@ -343,6 +343,9 @@ fn create_generic_args<'tcx>(
             // child generics in trait.
             let parent = tcx.local_parent(delegation_id);
             parent_args = tcx.impl_trait_header(parent).trait_ref.instantiate_identity().args;
+
+            assert!(child_args.is_empty(), "Child args can not be used in trait impl case");
+
             tcx.mk_args(&delegation_args[delegation_parent_args_count..])
         }