Blanket impl of super trait with method returning associated type: "incompatible type for trait"

[TimNN]

I tried this code:

pub trait Super {
    type X;

    // Change return type to `()` and everything is fine.
    fn method(&self) -> Self::X;
}

// Remove the `: Super` and everything is fine.
pub trait Helper: Super {}

impl<T: Helper> Super for T {
    type X = ();

    fn method(&self) {}
}

I expected to see this happen: The code compiles

Instead, this happened: The code fails to compile.

Maybe this is working as intended, but intuitively I wouldn't have expected the Helper: Super to make a difference for the impl Super for T.

The type error is a lot more confusing if the associated type is implicit, (i.e. -> impl Future or async fn), because that results in "expected signature fn(&_) -> X, found signature fn(&_) -> X"

error[E0053]: method `method` has an incompatible type for trait
  --> src/lib.rs:14:21
   |
14 |     fn method(&self) {}
   |                     ^ expected associated type, found `()`
   |
note: type in trait
  --> src/lib.rs:5:25
   |
5  |     fn method(&self) -> Self::X;
   |                         ^^^^^^^
   = note: expected signature `fn(&_) -> <T as Super>::X`
              found signature `fn(&_) -> ()`

Meta

rustc --version --verbose:

Build using the Nightly version: 1.89.0-nightly(2025-05-30 70b3f4666e24ce22fc32)

[QuineDot]

You can also make the associated type part of the super trait bound.

pub trait Helper: Super<X = ()> {}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=11562fb9c7a961b5cebbf05b4868ab24

[TimNN]

Thanks for the suggestion, @QuineDot! This does indeed work for the simple case example I gave.

But I don't think there's a way to do that if the associated type is implicit (e.g. if fn method was instead async fn method)

[Noratrieb]

I think what is happening here is that the trait solver chooses the generic implementation T: Super from the where clauses when resolving T::X, which does not resolve to ().
This comes up frequently, but that's just how it works.