Auto merge of #126161 - Bryanskiy:delegation-generics-4, r=petrochenkov

Delegation: support generics in associated delegation items

This is a continuation of https://github.com/rust-lang/rust/pull/125929.

[design](https://github.com/Bryanskiy/posts/blob/master/delegation%20in%20generic%20contexts.md)

Generic parameters inheritance was implemented in all contexts. Generic arguments are not yet supported.

r? `@petrochenkov`

12 files changed, 417 insertions, 325 deletions

diff --git a/tests/ui/delegation/generics/impl-to-free-fn-pass.rs b/tests/ui/delegation/generics/impl-to-free-fn-pass.rs
new file mode 100644
index 00000000000..3b39a457467
--- /dev/null
+++ b/tests/ui/delegation/generics/impl-to-free-fn-pass.rs
@@ -0,0 +1,29 @@
+//@ run-pass
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+mod to_reuse {
+    pub fn foo<T, U>(_: T, y: U) -> U { y }
+}
+
+trait Trait<T> {
+    fn foo(&self, x: T) -> T { x }
+}
+struct F;
+impl<T> Trait<T> for F {}
+
+struct S<T>(F, T);
+
+impl<T, U> Trait<T> for S<U> {
+    reuse to_reuse::foo { &self.0 }
+}
+
+impl<T> S<T> {
+    reuse to_reuse::foo;
+}
+
+fn main() {
+    let s = S(F, 42);
+    assert_eq!(S::<i32>::foo(F, 1), 1);
+    assert_eq!(<S<_> as Trait<_>>::foo(&s, 1), 1);
+}
diff --git a/tests/ui/delegation/generics/impl-to-trait-method.rs b/tests/ui/delegation/generics/impl-to-trait-method.rs
new file mode 100644
index 00000000000..39e32e2ed15
--- /dev/null
+++ b/tests/ui/delegation/generics/impl-to-trait-method.rs
@@ -0,0 +1,44 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+mod bounds {
+    trait Trait0 {}
+
+    trait Trait1<T> {
+        fn foo<U>(&self)
+        where
+            T: Trait0,
+            U: Trait0,
+            Self: Trait0,
+            //~^ ERROR the trait bound `bounds::S: Trait0` is not satisfied
+        {
+        }
+    }
+
+    struct F;
+    impl<T> Trait1<T> for F {}
+
+    struct S(F);
+
+    impl<T> Trait1<T> for S {
+        reuse Trait1::<T>::foo { &self.0 }
+        //~^ ERROR the trait bound `bounds::F: Trait0` is not satisfied
+    }
+}
+
+mod unconstrained_parameter {
+    trait Trait<T> {
+        fn foo(&self) {}
+    }
+
+    struct F;
+    impl<T> Trait<T> for F {}
+
+    struct S(F);
+    impl S {
+        reuse Trait::foo { &self.0 }
+        //~^ ERROR type annotations needed
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/delegation/generics/impl-to-trait-method.stderr b/tests/ui/delegation/generics/impl-to-trait-method.stderr
new file mode 100644
index 00000000000..aeba30de043
--- /dev/null
+++ b/tests/ui/delegation/generics/impl-to-trait-method.stderr
@@ -0,0 +1,49 @@
+error[E0277]: the trait bound `bounds::S: Trait0` is not satisfied
+  --> $DIR/impl-to-trait-method.rs:12:19
+   |
+LL |             Self: Trait0,
+   |                   ^^^^^^ the trait `Trait0` is not implemented for `bounds::S`
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/impl-to-trait-method.rs:5:5
+   |
+LL |     trait Trait0 {}
+   |     ^^^^^^^^^^^^
+   = help: see issue #48214
+help: add `#![feature(trivial_bounds)]` to the crate attributes to enable
+   |
+LL + #![feature(trivial_bounds)]
+   |
+
+error[E0277]: the trait bound `bounds::F: Trait0` is not satisfied
+  --> $DIR/impl-to-trait-method.rs:24:34
+   |
+LL |         reuse Trait1::<T>::foo { &self.0 }
+   |                            ---   ^^^^^^^ the trait `Trait0` is not implemented for `bounds::F`
+   |                            |
+   |                            required by a bound introduced by this call
+   |
+help: this trait has no implementations, consider adding one
+  --> $DIR/impl-to-trait-method.rs:5:5
+   |
+LL |     trait Trait0 {}
+   |     ^^^^^^^^^^^^
+note: required by a bound in `Trait1::foo`
+  --> $DIR/impl-to-trait-method.rs:12:19
+   |
+LL |         fn foo<U>(&self)
+   |            --- required by a bound in this associated function
+...
+LL |             Self: Trait0,
+   |                   ^^^^^^ required by this bound in `Trait1::foo`
+
+error[E0282]: type annotations needed
+  --> $DIR/impl-to-trait-method.rs:39:22
+   |
+LL |         reuse Trait::foo { &self.0 }
+   |                      ^^^ cannot infer type for type parameter `T` declared on the trait `Trait`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0277, E0282.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/delegation/generics/impl-trait-to-trait-method-pass.rs b/tests/ui/delegation/generics/impl-trait-to-trait-method-pass.rs
new file mode 100644
index 00000000000..72440fe82d4
--- /dev/null
+++ b/tests/ui/delegation/generics/impl-trait-to-trait-method-pass.rs
@@ -0,0 +1,77 @@
+//@ run-pass
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+use std::iter::{Iterator, Map};
+
+pub mod same_trait {
+    use super::*;
+
+    pub struct MapOuter<I, F> {
+        pub inner: Map<I, F>
+    }
+
+    impl<B, I: Iterator, F> Iterator for MapOuter<I, F>
+    where
+        F: FnMut(I::Item) -> B,
+    {
+        type Item = <Map<I, F> as Iterator>::Item;
+
+        reuse Iterator::{next, fold} { self.inner }
+    }
+}
+use same_trait::MapOuter;
+
+mod another_trait {
+    use super::*;
+
+    trait ZipImpl<A, B> {
+        type Item;
+
+        fn next(&mut self) -> Option<Self::Item>;
+    }
+
+    pub struct Zip<A, B> {
+        pub a: A,
+        pub b: B,
+    }
+
+    impl<A: Iterator, B: Iterator> ZipImpl<A, B> for Zip<A, B> {
+        type Item = (A::Item, B::Item);
+
+        fn next(&mut self) -> Option<(A::Item, B::Item)> {
+            let x = self.a.next()?;
+            let y = self.b.next()?;
+            Some((x, y))
+        }
+    }
+
+    impl<A: Iterator, B: Iterator> Iterator for Zip<A, B> {
+        type Item = (A::Item, B::Item);
+
+        // Parameters are inherited from `Iterator::next`, not from `ZipImpl::next`.
+        // Otherwise, there would be a compilation error due to an unconstrained parameter.
+        reuse ZipImpl::next;
+    }
+}
+use another_trait::Zip;
+
+fn main() {
+    {
+        let x = vec![1, 2, 3];
+        let iter = x.iter().map(|val| val * 2);
+        let outer_iter = MapOuter { inner: iter };
+        let val = outer_iter.fold(0, |acc, x| acc + x);
+        assert_eq!(val, 12);
+    }
+
+    {
+        let x = vec![1, 2];
+        let y = vec![4, 5];
+
+        let mut zip = Zip { a: x.iter(), b: y.iter() };
+        assert_eq!(zip.next(), Some((&1, &4)));
+        assert_eq!(zip.next(), Some((&2, &5)));
+    }
+}
diff --git a/tests/ui/delegation/generics/inherent-impl-to-trait-method-pass.rs b/tests/ui/delegation/generics/inherent-impl-to-trait-method-pass.rs
new file mode 100644
index 00000000000..6f3bb178971
--- /dev/null
+++ b/tests/ui/delegation/generics/inherent-impl-to-trait-method-pass.rs
@@ -0,0 +1,23 @@
+//@ run-pass
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+trait Trait<T> {
+    fn foo<U>(&self, x: T, y: U) -> (T, U) {
+        (x, y)
+    }
+}
+
+impl<T> Trait<T> for () {}
+struct S<T>(T, ());
+
+impl<T> S<T> {
+    reuse Trait::foo { self.1 }
+}
+
+
+fn main() {
+    let s = S((), ());
+    assert_eq!(s.foo(1u32, 2i32), (1u32, 2i32));
+}
diff --git a/tests/ui/delegation/generics/trait-method-to-other-pass.rs b/tests/ui/delegation/generics/trait-method-to-other-pass.rs
new file mode 100644
index 00000000000..2094705a05c
--- /dev/null
+++ b/tests/ui/delegation/generics/trait-method-to-other-pass.rs
@@ -0,0 +1,30 @@
+//@ run-pass
+
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+mod to_reuse {
+    pub fn foo<T>(x: T) -> T { x }
+}
+
+trait Trait1<T, U> {
+    fn foo(&self, _: T, x: U) -> U { x }
+}
+
+#[derive(Default)]
+struct F;
+
+impl<T, U> Trait1<T, U> for F {}
+
+trait Trait2<T> {
+    fn get_f(&self) -> &F { &F }
+    reuse Trait1::foo as bar { self.get_f() }
+    reuse to_reuse::foo as baz;
+}
+
+impl Trait2<u64> for F {}
+
+fn main() {
+    assert_eq!(F.bar(1u8, 2u16), 2u16);
+    assert_eq!(F::baz(1u8), 1u8);
+}
diff --git a/tests/ui/delegation/ice-issue-124347.rs b/tests/ui/delegation/ice-issue-124347.rs
index 3bfae8face5..ee2bf9e33eb 100644
--- a/tests/ui/delegation/ice-issue-124347.rs
+++ b/tests/ui/delegation/ice-issue-124347.rs
@@ -1,12 +1,12 @@
 #![feature(fn_delegation)]
 #![allow(incomplete_features)]
 
+// FIXME(fn_delegation): `recursive delegation` error should be emitted here
 trait Trait {
     reuse Trait::foo { &self.0 }
-    //~^ ERROR recursive delegation is not supported yet
+    //~^ ERROR cycle detected when computing generics of `Trait::foo`
 }
 
-// FIXME(fn_delegation): `recursive delegation` error should be emitted here
 reuse foo;
 //~^ ERROR cycle detected when computing generics of `foo`
 
diff --git a/tests/ui/delegation/ice-issue-124347.stderr b/tests/ui/delegation/ice-issue-124347.stderr
index 87dd75ffec8..bd0bc970b94 100644
--- a/tests/ui/delegation/ice-issue-124347.stderr
+++ b/tests/ui/delegation/ice-issue-124347.stderr
@@ -1,8 +1,16 @@
-error: recursive delegation is not supported yet
-  --> $DIR/ice-issue-124347.rs:5:18
+error[E0391]: cycle detected when computing generics of `Trait::foo`
+  --> $DIR/ice-issue-124347.rs:6:18
    |
 LL |     reuse Trait::foo { &self.0 }
-   |                  ^^^ callee defined here
+   |                  ^^^
+   |
+   = note: ...which immediately requires computing generics of `Trait::foo` again
+note: cycle used when inheriting delegation signature
+  --> $DIR/ice-issue-124347.rs:6:18
+   |
+LL |     reuse Trait::foo { &self.0 }
+   |                  ^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
 error[E0391]: cycle detected when computing generics of `foo`
   --> $DIR/ice-issue-124347.rs:10:7
diff --git a/tests/ui/delegation/not-supported.rs b/tests/ui/delegation/not-supported.rs
deleted file mode 100644
index d5ac68ecf1b..00000000000
--- a/tests/ui/delegation/not-supported.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![feature(const_trait_impl)]
-#![feature(c_variadic)]
-#![feature(effects)]
-#![feature(fn_delegation)]
-#![allow(incomplete_features)]
-
-mod generics {
-    trait GenericTrait<T> {
-        fn bar(&self, x: T) -> T { x }
-        fn bar1() {}
-    }
-    trait Trait {
-        fn foo(&self, x: i32) -> i32 { x }
-        fn foo1<'a>(&self, x: &'a i32) -> &'a i32 { x }
-        fn foo2<T>(&self, x: T) -> T { x }
-        fn foo3<'a: 'a>(_: &'a u32) {}
-
-        reuse GenericTrait::bar;
-        //~^ ERROR early bound generics are not supported for associated delegation items
-        reuse GenericTrait::bar1;
-        //~^ ERROR early bound generics are not supported for associated delegation items
-    }
-
-    struct F;
-    impl Trait for F {}
-    impl<T> GenericTrait<T> for F {}
-
-    struct S(F);
-
-    impl<T> GenericTrait<T> for S {
-        reuse <F as GenericTrait<T>>::bar { &self.0 }
-        //~^ ERROR early bound generics are not supported for associated delegation items
-        reuse GenericTrait::<T>::bar1;
-        //~^ ERROR early bound generics are not supported for associated delegation items
-    }
-
-    impl GenericTrait<()> for () {
-        reuse GenericTrait::bar { &F }
-        //~^ ERROR early bound generics are not supported for associated delegation items
-        reuse GenericTrait::bar1;
-        //~^ ERROR early bound generics are not supported for associated delegation items
-    }
-
-    impl Trait for &S {
-        reuse Trait::foo;
-        //~^ ERROR early bound generics are not supported for associated delegation items
-    }
-
-    impl Trait for S {
-        reuse Trait::foo1 { &self.0 }
-        reuse Trait::foo2 { &self.0 }
-        //~^ ERROR early bound generics are not supported for associated delegation items
-        //~| ERROR method `foo2` has 0 type parameters but its trait declaration has 1 type parameter
-        reuse <F as Trait>::foo3;
-        //~^ ERROR early bound generics are not supported for associated delegation items
-        //~| ERROR lifetime parameters or bounds on associated function `foo3` do not match the trait declaration
-    }
-
-    struct GenericS<T>(T);
-    impl<T> Trait for GenericS<T> {
-        reuse Trait::foo { &self.0 }
-        //~^ ERROR early bound generics are not supported for associated delegation items
-    }
-}
-
-mod opaque {
-    trait Trait {}
-    impl Trait for () {}
-
-    mod to_reuse {
-        use super::Trait;
-
-        pub fn opaque_ret() -> impl Trait { unimplemented!() }
-        //~^ warn: this function depends on never type fallback being `()`
-        //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-    }
-
-    trait ToReuse {
-        fn opaque_ret() -> impl Trait { unimplemented!() }
-        //~^ warn: this function depends on never type fallback being `()`
-        //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-    }
-
-    // FIXME: Inherited `impl Trait`s create query cycles when used inside trait impls.
-    impl ToReuse for u8 {
-        reuse to_reuse::opaque_ret; //~ ERROR cycle detected when computing type
-    }
-    impl ToReuse for u16 {
-        reuse ToReuse::opaque_ret; //~ ERROR cycle detected when computing type
-    }
-}
-
-mod recursive {
-    mod to_reuse1 {
-        pub mod to_reuse2 {
-            pub fn foo() {}
-        }
-
-        pub reuse to_reuse2::foo;
-    }
-
-    reuse to_reuse1::foo;
-    //~^ ERROR recursive delegation is not supported yet
-}
-
-mod effects {
-    #[const_trait]
-    trait Trait {
-        fn foo();
-    }
-
-    reuse Trait::foo;
-    //~^ ERROR delegation to a function with effect parameter is not supported yet
-}
-
-fn main() {}
diff --git a/tests/ui/delegation/not-supported.stderr b/tests/ui/delegation/not-supported.stderr
deleted file mode 100644
index 14d6b374bd2..00000000000
--- a/tests/ui/delegation/not-supported.stderr
+++ /dev/null
@@ -1,204 +0,0 @@
-error: using `#![feature(effects)]` without enabling next trait solver globally
-   |
-   = note: the next trait solver must be enabled globally for the effects feature to work correctly
-   = help: use `-Znext-solver` to enable
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:18:29
-   |
-LL |         fn bar(&self, x: T) -> T { x }
-   |         ------------------------ callee defined here
-...
-LL |         reuse GenericTrait::bar;
-   |                             ^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:20:29
-   |
-LL |         fn bar1() {}
-   |         --------- callee defined here
-...
-LL |         reuse GenericTrait::bar1;
-   |                             ^^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:31:39
-   |
-LL |         fn bar(&self, x: T) -> T { x }
-   |         ------------------------ callee defined here
-...
-LL |         reuse <F as GenericTrait<T>>::bar { &self.0 }
-   |                                       ^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:33:34
-   |
-LL |         fn bar1() {}
-   |         --------- callee defined here
-...
-LL |         reuse GenericTrait::<T>::bar1;
-   |                                  ^^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:38:29
-   |
-LL |         fn bar(&self, x: T) -> T { x }
-   |         ------------------------ callee defined here
-...
-LL |         reuse GenericTrait::bar { &F }
-   |                             ^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:40:29
-   |
-LL |         fn bar1() {}
-   |         --------- callee defined here
-...
-LL |         reuse GenericTrait::bar1;
-   |                             ^^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:45:22
-   |
-LL |         fn foo(&self, x: i32) -> i32 { x }
-   |         ---------------------------- callee defined here
-...
-LL |         reuse Trait::foo;
-   |                      ^^^
-
-error[E0049]: method `foo2` has 0 type parameters but its trait declaration has 1 type parameter
-  --> $DIR/not-supported.rs:51:22
-   |
-LL |         fn foo2<T>(&self, x: T) -> T { x }
-   |                 - expected 1 type parameter
-...
-LL |         reuse Trait::foo2 { &self.0 }
-   |                      ^^^^ found 0 type parameters
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:54:29
-   |
-LL |         fn foo3<'a: 'a>(_: &'a u32) {}
-   |         --------------------------- callee defined here
-...
-LL |         reuse <F as Trait>::foo3;
-   |                             ^^^^
-
-error[E0195]: lifetime parameters or bounds on associated function `foo3` do not match the trait declaration
-  --> $DIR/not-supported.rs:54:29
-   |
-LL |         fn foo3<'a: 'a>(_: &'a u32) {}
-   |                -------- lifetimes in impl do not match this associated function in trait
-...
-LL |         reuse <F as Trait>::foo3;
-   |                             ^^^^ lifetimes do not match associated function in trait
-
-error: delegation to a function with effect parameter is not supported yet
-  --> $DIR/not-supported.rs:112:18
-   |
-LL |         fn foo();
-   |         --------- callee defined here
-...
-LL |     reuse Trait::foo;
-   |                  ^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:61:22
-   |
-LL |         fn foo(&self, x: i32) -> i32 { x }
-   |         ---------------------------- callee defined here
-...
-LL |         reuse Trait::foo { &self.0 }
-   |                      ^^^
-
-error: early bound generics are not supported for associated delegation items
-  --> $DIR/not-supported.rs:51:22
-   |
-LL |         fn foo2<T>(&self, x: T) -> T { x }
-   |         ---------------------------- callee defined here
-...
-LL |         reuse Trait::foo2 { &self.0 }
-   |                      ^^^^
-
-warning: this function depends on never type fallback being `()`
-  --> $DIR/not-supported.rs:79:9
-   |
-LL |         fn opaque_ret() -> impl Trait { unimplemented!() }
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
-   = help: specify the types explicitly
-note: in edition 2024, the requirement `!: opaque::Trait` will fail
-  --> $DIR/not-supported.rs:79:28
-   |
-LL |         fn opaque_ret() -> impl Trait { unimplemented!() }
-   |                            ^^^^^^^^^^
-   = note: `#[warn(dependency_on_unit_never_type_fallback)]` on by default
-
-error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/not-supported.rs:85:5: 85:24>::{synthetic#0}`
-  --> $DIR/not-supported.rs:86:25
-   |
-LL |         reuse to_reuse::opaque_ret;
-   |                         ^^^^^^^^^^
-   |
-note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
-  --> $DIR/not-supported.rs:86:25
-   |
-LL |         reuse to_reuse::opaque_ret;
-   |                         ^^^^^^^^^^
-   = note: ...which again requires computing type of `opaque::<impl at $DIR/not-supported.rs:85:5: 85:24>::{synthetic#0}`, completing the cycle
-note: cycle used when checking that `opaque::<impl at $DIR/not-supported.rs:85:5: 85:24>` is well-formed
-  --> $DIR/not-supported.rs:85:5
-   |
-LL |     impl ToReuse for u8 {
-   |     ^^^^^^^^^^^^^^^^^^^
-   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
-
-warning: this function depends on never type fallback being `()`
-  --> $DIR/not-supported.rs:73:9
-   |
-LL |         pub fn opaque_ret() -> impl Trait { unimplemented!() }
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-   = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
-   = help: specify the types explicitly
-note: in edition 2024, the requirement `!: opaque::Trait` will fail
-  --> $DIR/not-supported.rs:73:32
-   |
-LL |         pub fn opaque_ret() -> impl Trait { unimplemented!() }
-   |                                ^^^^^^^^^^
-
-error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/not-supported.rs:88:5: 88:25>::{synthetic#0}`
-  --> $DIR/not-supported.rs:89:24
-   |
-LL |         reuse ToReuse::opaque_ret;
-   |                        ^^^^^^^^^^
-   |
-note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
-  --> $DIR/not-supported.rs:89:24
-   |
-LL |         reuse ToReuse::opaque_ret;
-   |                        ^^^^^^^^^^
-   = note: ...which again requires computing type of `opaque::<impl at $DIR/not-supported.rs:88:5: 88:25>::{synthetic#0}`, completing the cycle
-note: cycle used when checking that `opaque::<impl at $DIR/not-supported.rs:88:5: 88:25>` is well-formed
-  --> $DIR/not-supported.rs:88:5
-   |
-LL |     impl ToReuse for u16 {
-   |     ^^^^^^^^^^^^^^^^^^^^
-   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
-
-error: recursive delegation is not supported yet
-  --> $DIR/not-supported.rs:102:22
-   |
-LL |         pub reuse to_reuse2::foo;
-   |                              --- callee defined here
-...
-LL |     reuse to_reuse1::foo;
-   |                      ^^^
-
-error: aborting due to 17 previous errors; 2 warnings emitted
-
-Some errors have detailed explanations: E0049, E0195, E0391.
-For more information about an error, try `rustc --explain E0049`.
diff --git a/tests/ui/delegation/unsupported.rs b/tests/ui/delegation/unsupported.rs
new file mode 100644
index 00000000000..e57effff48d
--- /dev/null
+++ b/tests/ui/delegation/unsupported.rs
@@ -0,0 +1,57 @@
+#![feature(const_trait_impl)]
+#![feature(c_variadic)]
+#![feature(effects)]
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+mod opaque {
+    trait Trait {}
+    impl Trait for () {}
+
+    mod to_reuse {
+        use super::Trait;
+
+        pub fn opaque_ret() -> impl Trait { unimplemented!() }
+        //~^ warn: this function depends on never type fallback being `()`
+        //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    }
+
+    trait ToReuse {
+        fn opaque_ret() -> impl Trait { unimplemented!() }
+        //~^ warn: this function depends on never type fallback being `()`
+        //~| warn: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+    }
+
+    // FIXME: Inherited `impl Trait`s create query cycles when used inside trait impls.
+    impl ToReuse for u8 {
+        reuse to_reuse::opaque_ret; //~ ERROR cycle detected when computing type
+    }
+    impl ToReuse for u16 {
+        reuse ToReuse::opaque_ret; //~ ERROR cycle detected when computing type
+    }
+}
+
+mod recursive {
+    mod to_reuse1 {
+        pub mod to_reuse2 {
+            pub fn foo() {}
+        }
+
+        pub reuse to_reuse2::foo;
+    }
+
+    reuse to_reuse1::foo;
+    //~^ ERROR recursive delegation is not supported yet
+}
+
+mod effects {
+    #[const_trait]
+    trait Trait {
+        fn foo();
+    }
+
+    reuse Trait::foo;
+    //~^ ERROR delegation to a function with effect parameter is not supported yet
+}
+
+fn main() {}
diff --git a/tests/ui/delegation/unsupported.stderr b/tests/ui/delegation/unsupported.stderr
new file mode 100644
index 00000000000..03ded300bb4
--- /dev/null
+++ b/tests/ui/delegation/unsupported.stderr
@@ -0,0 +1,95 @@
+error: using `#![feature(effects)]` without enabling next trait solver globally
+   |
+   = note: the next trait solver must be enabled globally for the effects feature to work correctly
+   = help: use `-Znext-solver` to enable
+
+warning: this function depends on never type fallback being `()`
+  --> $DIR/unsupported.rs:20:9
+   |
+LL |         fn opaque_ret() -> impl Trait { unimplemented!() }
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
+   = help: specify the types explicitly
+note: in edition 2024, the requirement `!: opaque::Trait` will fail
+  --> $DIR/unsupported.rs:20:28
+   |
+LL |         fn opaque_ret() -> impl Trait { unimplemented!() }
+   |                            ^^^^^^^^^^
+   = note: `#[warn(dependency_on_unit_never_type_fallback)]` on by default
+
+error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:26:5: 26:24>::{synthetic#0}`
+  --> $DIR/unsupported.rs:27:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   |
+note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
+  --> $DIR/unsupported.rs:27:25
+   |
+LL |         reuse to_reuse::opaque_ret;
+   |                         ^^^^^^^^^^
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:26:5: 26:24>::{synthetic#0}`, completing the cycle
+note: cycle used when checking that `opaque::<impl at $DIR/unsupported.rs:26:5: 26:24>` is well-formed
+  --> $DIR/unsupported.rs:26:5
+   |
+LL |     impl ToReuse for u8 {
+   |     ^^^^^^^^^^^^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+warning: this function depends on never type fallback being `()`
+  --> $DIR/unsupported.rs:14:9
+   |
+LL |         pub fn opaque_ret() -> impl Trait { unimplemented!() }
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #123748 <https://github.com/rust-lang/rust/issues/123748>
+   = help: specify the types explicitly
+note: in edition 2024, the requirement `!: opaque::Trait` will fail
+  --> $DIR/unsupported.rs:14:32
+   |
+LL |         pub fn opaque_ret() -> impl Trait { unimplemented!() }
+   |                                ^^^^^^^^^^
+
+error[E0391]: cycle detected when computing type of `opaque::<impl at $DIR/unsupported.rs:29:5: 29:25>::{synthetic#0}`
+  --> $DIR/unsupported.rs:30:24
+   |
+LL |         reuse ToReuse::opaque_ret;
+   |                        ^^^^^^^^^^
+   |
+note: ...which requires comparing an impl and trait method signature, inferring any hidden `impl Trait` types in the process...
+  --> $DIR/unsupported.rs:30:24
+   |
+LL |         reuse ToReuse::opaque_ret;
+   |                        ^^^^^^^^^^
+   = note: ...which again requires computing type of `opaque::<impl at $DIR/unsupported.rs:29:5: 29:25>::{synthetic#0}`, completing the cycle
+note: cycle used when checking that `opaque::<impl at $DIR/unsupported.rs:29:5: 29:25>` is well-formed
+  --> $DIR/unsupported.rs:29:5
+   |
+LL |     impl ToReuse for u16 {
+   |     ^^^^^^^^^^^^^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error: recursive delegation is not supported yet
+  --> $DIR/unsupported.rs:43:22
+   |
+LL |         pub reuse to_reuse2::foo;
+   |                              --- callee defined here
+...
+LL |     reuse to_reuse1::foo;
+   |                      ^^^
+
+error: delegation to a function with effect parameter is not supported yet
+  --> $DIR/unsupported.rs:53:18
+   |
+LL |         fn foo();
+   |         --------- callee defined here
+...
+LL |     reuse Trait::foo;
+   |                  ^^^
+
+error: aborting due to 5 previous errors; 2 warnings emitted
+
+For more information about this error, try `rustc --explain E0391`.