Always generate generics that match trait in impl trait scenario

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

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

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -38,9 +38,15 @@ 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> {
@@ -127,12 +133,20 @@ impl<'hir> HirOrAstGenerics<'hir> {
 }
 
 impl<'a> GenericsGenerationResult<'a> {
-    fn new(generics: DelegationGenerics<Generics>) -> GenericsGenerationResult<'a> {
+    fn new(
+        generics: DelegationGenerics<Generics>,
+        propagation_kind: PropagationKind,
+    ) -> 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> {
@@ -147,6 +161,8 @@ 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
@@ -189,6 +205,8 @@ 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)
@@ -215,10 +233,38 @@ impl<'hir> LoweringContext<'_, 'hir> {
         item_id: NodeId,
         span: Span,
     ) -> GenericsGenerationResults<'hir> {
-        let delegation_in_free_ctx = !matches!(
-            self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id))),
-            DefKind::Trait | DefKind::Impl { .. }
-        );
+        let delegation_parent_kind =
+            self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id)));
+
+        // 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,
+            );
+
+            // 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);
+
+            return GenericsGenerationResults { parent, child };
+        }
+
+        let delegation_in_free_ctx =
+            !matches!(delegation_parent_kind, DefKind::Trait | DefKind::Impl { .. });
 
         let root_function_in_trait =
             matches!(self.tcx.def_kind(self.tcx.parent(root_fn_id)), DefKind::Trait);
@@ -263,8 +309,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         };
 
         GenericsGenerationResults {
-            parent: GenericsGenerationResult::new(parent_generics),
-            child: GenericsGenerationResult::new(child_generics),
+            parent: GenericsGenerationResult::new(parent_generics, PropagationKind::Allowed),
+            child: GenericsGenerationResult::new(child_generics, PropagationKind::Allowed),
         }
     }
 

compiler/rustc_hir_analysis/src/delegation.rs

@@ -339,7 +339,8 @@ fn create_generic_args<'tcx>(
 
         (FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
             // Special case, as user specifies Trait args in impl trait header, we want to treat
-            // them as parent args.
+            // them as parent args. We always generate a function whose generics match
+            // child generics in trait.
             let parent = tcx.local_parent(delegation_id);
             parent_args = tcx.impl_trait_header(parent).trait_ref.instantiate_identity().args;
             tcx.mk_args(&delegation_args[delegation_parent_args_count..])

tests/ui/delegation/generics/impl-trait-to-free-and-trait-errors.rs

@@ -0,0 +1,171 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+#![allow(late_bound_lifetime_arguments)]
+
+mod test_1 {
+    mod to_reuse {
+        pub fn foo<'a: 'a, 'b: 'b, A, B, const N: usize>() {}
+        pub fn bar<'a: 'a, 'b: 'b, A, B, const N: usize>(_x: &super::XX) {}
+    }
+
+    trait Trait<'a, 'b, 'c, A, B, const N: usize>: Sized {
+        fn foo<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+
+        fn foo1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+    }
+
+    trait Trait1<'a, 'b, 'c, A, B, const N: usize>: Sized {
+        fn foo1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+    }
+
+    #[allow(dead_code)] // Fields are used instead of phantom data for generics use
+    struct X<'x1, 'x2, 'x3, 'x4, X1, X2, const X3: usize>(
+        &'x1 X1, &'x2 X2, &'x3 X1, &'x4 [usize; X3]);
+    type XX = X::<'static, 'static, 'static, 'static, i32, i32, 3>;
+
+    impl<'a, 'b, 'c, A, B, const N: usize> Trait<'a, 'b, 'c, A, B, N> for XX {
+        reuse to_reuse::foo;
+        //~^ ERROR: type annotations needed
+        reuse to_reuse::bar;
+        //~^ ERROR: type annotations needed
+
+        reuse Trait1::foo1;
+        //~^ ERROR: type annotations needed
+        //~| ERROR: type annotations needed
+        reuse Trait1::bar1;
+        //~^ ERROR: no method named `bar1` found for reference
+    }
+}
+
+mod test_2 {
+    mod to_reuse {
+        pub fn foo<A, B, const N: usize>() {}
+        pub fn bar<A, B, const N: usize>(_x: &super::X) {}
+    }
+
+    trait Trait<'a, 'b, 'c, A, B, const N: usize>: Sized {
+        fn foo<AA, BB, const NN: usize>() {}
+        fn bar<AA, BB, const NN: usize>(&self) {}
+
+        fn foo1<AA, BB, const NN: usize>() {}
+        fn bar1<AA, BB, const NN: usize>(&self) {}
+    }
+
+    trait Trait1<'a, 'b, 'c, A, B, const N: usize>: Sized {
+        fn foo1<AA, BB, const NN: usize>() {}
+        fn bar1<AA, BB, const NN: usize>(&self) {}
+    }
+
+    struct X;
+    impl<'a, A, B, const N: usize> Trait<'a, 'static, 'static, A, B, N> for X {
+        reuse to_reuse::foo;
+        //~^ ERROR: type annotations needed
+        reuse to_reuse::bar;
+        //~^ ERROR: type annotations needed
+
+        reuse Trait1::foo1;
+        //~^ ERROR: type annotations needed
+        //~| ERROR: type annotations needed
+        reuse Trait1::bar1;
+        //~^ ERROR: no method named `bar1` found for reference
+    }
+}
+
+mod test_4 {
+    mod to_reuse {
+        pub fn foo<'a: 'a, 'b: 'b, A, B, const N: usize>() {}
+        pub fn bar<'a: 'a, 'b: 'b, A, B, const N: usize>(_x: &super::X) {}
+    }
+
+    trait Trait<A, B, const N: usize>: Sized {
+        fn foo<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+
+        fn foo1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+    }
+
+    trait Trait1<A, B, const N: usize>: Sized {
+        fn foo1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn bar1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>(&self) {}
+    }
+
+    struct X;
+    impl<'a, 'c, A, B, const N: usize> Trait<A, B, N> for X {
+        reuse to_reuse::foo;
+        //~^ ERROR: type annotations needed
+        reuse to_reuse::bar;
+        //~^ ERROR: type annotations needed
+
+        reuse Trait1::foo1;
+        //~^ ERROR: type annotations needed
+        //~| ERROR: type annotations needed
+        reuse Trait1::bar1;
+        //~^ ERROR: no method named `bar1` found for reference
+    }
+}
+
+mod test_5 {
+    mod to_reuse {
+        pub fn foo<'a: 'a, 'b: 'b, A, B, const N: usize>() {}
+    }
+
+    trait Trait: Sized {
+        fn foo<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+        fn foo1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+    }
+
+    trait Trait1: Sized {
+        fn foo1<'x: 'x, 'y: 'y, AA, BB, const NN: usize>() {}
+    }
+
+    struct X<A, B>(A, B);
+    impl<'a, 'c, A, B> Trait for X<A, B> {
+        reuse to_reuse::foo;
+        //~^ ERROR: type annotations needed
+
+        reuse Trait1::foo1;
+        //~^ ERROR: type annotations needed
+        //~| ERROR: type annotations needed
+    }
+}
+
+mod test_6 {
+    mod to_reuse {
+        pub fn foo<A, B, const N: usize>() {}
+        pub fn bar<A, B, const N: usize>(_x: &super::X) {}
+    }
+
+    trait Trait<A, B, const N: usize>: Sized {
+        fn foo<AA, BB, const NN: usize>() {}
+        fn bar<AA, BB, const NN: usize>(&self) {}
+
+        fn foo1<AA, BB, const NN: usize>() {}
+        fn bar1<AA, BB, const NN: usize>(&self) {}
+    }
+
+    trait Trait1<A, B, const N: usize>: Sized {
+        fn foo1<AA, BB, const NN: usize>() {}
+        fn bar1<AA, BB, const NN: usize>(&self) {}
+    }
+
+    struct X;
+    impl<'a, 'c, A, B, const N: usize> Trait<A, B, N> for X {
+        reuse to_reuse::foo;
+        //~^ ERROR: type annotations needed
+        reuse to_reuse::bar;
+        //~^ ERROR: type annotations needed
+
+        reuse Trait1::foo1;
+        //~^ ERROR: type annotations needed
+        //~| ERROR: type annotations needed
+        reuse Trait1::bar1;
+        //~^ ERROR: no method named `bar1` found for reference
+    }
+}
+
+fn main() {
+}